v1.0.0-rc.153 (#63)

This is an UNSTABLE release. It includes many experimental features, as well as many AI generated fixes. We recommend using rc.152 for production use.

* jfjoch_broker: Add EXPERIMENTAL pixelrefine mode for image processing
* jfjoch_broker: Allow to load user mask from 8-bit and 16-bit TIFF files
* jfjoch_broker: Add ROI calculation in non-FPGA workflow
* jfjoch_broker: Fixes to TCP image pusher
* jfjoch_broker: Remove NUMA bindings
* jfjoch_broker: Improvements to indexing
* jfjoch_broker: For PSI EIGER, trimming energies are taken from the detector configuration (now compulsory) instead of hardcoded values
* jfjoch_writer: Save ROI definitions and the per-pixel ROI bitmap in the master file; azimuthal ROIs support phi (angular) sectors
* jfjoch_viewer: Major redesign with dockable panels and saved layouts, plus on-canvas creation/move/resize of box, circle and azimuthal ROIs
* jfjoch_viewer: Run jfjoch_process reprocessing jobs from inside the GUI and overlay per-run results

Reviewed-on: #63

common/ImageBuffer.cpp

@@ -6,29 +6,39 @@
 #include "JFJochException.h"
 #include "ZeroCopyReturnValue.h"
 
-#ifdef JFJOCH_USE_NUMA
-#include <numa.h>
-#endif
-#include <sys/mman.h>
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <thread>
+#include <vector>
 
+namespace {
+    // Zero the buffer in parallel so that each page is first-touched by whichever NUMA node the
+    // scheduler placed the zeroing thread on. With RAM headroom this approximates an interleaved
+    // placement for the random-access ring buffer, while also slashing the one-time cost of
+    // faulting in a 150-200 GB allocation. Replaces numa_alloc_interleaved + a single-threaded
+    // memset, so this file no longer needs libnuma.
+    void parallel_first_touch(uint8_t *buffer, size_t buffer_size) {
+        const unsigned n = std::max(1u, std::thread::hardware_concurrency());
+        const size_t chunk = (buffer_size + n - 1) / n;
+
+        std::vector<std::thread> threads;
+        for (size_t begin = 0; begin < buffer_size; begin += chunk) {
+            size_t len = std::min(chunk, buffer_size - begin);
+            threads.emplace_back([=] { memset(buffer + begin, 0, len); });
+        }
+        for (auto &t : threads)
+            t.join();
+    }
+}
 
 ImageBuffer::ImageBuffer(size_t buffer_size_bytes)
         : buffer_size(buffer_size_bytes) {
-
-#ifdef JFJOCH_USE_NUMA
-    buffer = static_cast<uint8_t *>(numa_alloc_interleaved(buffer_size));
+    buffer = static_cast<uint8_t *>(std::malloc(buffer_size));
     if (buffer == nullptr)
-        throw JFJochException(JFJochExceptionCategory::MemAllocFailed,
-            "Failed to allocate image buffer");
-
-    #else
-    buffer = (uint8_t *) mmap (nullptr, buffer_size, PROT_READ | PROT_WRITE,
-                               MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) ;
-    if (buffer == MAP_FAILED)
         throw JFJochException(JFJochExceptionCategory::MemAllocFailed,
                               "Failed to allocate image buffer");
-#endif
-    memset(buffer, 0, buffer_size);
+    parallel_first_touch(buffer, buffer_size);
 }
 
 ImageBuffer::~ImageBuffer() {
@@ -36,11 +46,7 @@ ImageBuffer::~ImageBuffer() {
     std::unique_lock ul(m);
     FinalizeInternal(ul);
 
-#ifdef JFJOCH_USE_NUMA
-    numa_free(buffer, buffer_size);
-#else
-    munmap(buffer, buffer_size);
-#endif
+    std::free(buffer);
 }
 
 void ImageBuffer::StartMeasurement(size_t in_location_size) {