image_analysis: share the read-only GPU lookup tables per device

One analysis engine is built per worker thread, and each uploaded its own copy of
tables that are pure functions of the detector geometry: the pixel -> azimuthal bin
map and the per-pixel corrections (both in AzIntEngineGPU AND again in
AdaptiveSpotFinderGPU, from the same mapping), plus the pixel mask. On an 18 Mpx
detector that is ~224 MB per worker; with 32 workers ~7 GB of device memory held 32
identical copies.

Upload each table once per GPU instead and hand every engine on that device a shared
pointer to it. The cache is keyed by (device, source-vector address) because workers
are pinned round-robin across GPUs, so on a multi-GPU node each device keeps its own
copy - a kernel may only read memory resident on the device it runs on - and the
table is freed on the device that allocated it. Entries are held weakly, so a table
goes away with the last engine using it.

Measured on an 18 Mpx detector, 32 worker threads, 16 GB card: the stills path went
from exhausting the card (OOM in de-novo indexing) to 8.6 GB peak, and a normal
rotation run from 14.6 GB to 7.4 GB - it had been running within 1.6 GB of the limit,
so any larger detector or second GPU consumer would have tipped it over. Per-worker
footprint drops 403 -> 173 MB. Merge statistics are unchanged on a six-crystal
regression subset, including two-pass runs where the second pass rebuilds the mapping
on refined geometry, and wall time is unchanged (13.5-13.8 s vs 13.8-14.1 s).

Also take the launch configuration from the current device rather than device 0 in
AzIntEngineGPU and ImagePreprocessorGPU: with round-robin pinning, device 0's SM count
and shared-memory size can belong to a different card than the one the kernels use.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

image_analysis/image_preprocessing/ImagePreprocessorGPU.cu

@@ -93,25 +93,23 @@ ImagePreprocessorGPU::ImagePreprocessorGPU(const DiffractionExperiment &experime
                                            std::shared_ptr<CudaStream> stream)
     : ImagePreprocessor(experiment),
       stream(stream),
-      gpu_mask(npixels),
       gpu_decompressed_image(npixels * sizeof(uint32_t)),  // Overshoot - if input image is 1- or 2-byte, then it is still fine, while memory loss is minimal
       gpu_stats(1),
       cpu_stats(1),
       cpu_stats_reg(cpu_stats) {
-    // Setup mask
+    // Setup mask. The same for every worker, so it is uploaded once per GPU and shared; keyed on the
+    // PixelMask's own vector, which the derived table is a pure function of.
     std::vector<uint8_t> mask_vec(npixels);
     for (int i = 0; i < npixels; i++)
         mask_vec[i] = (mask.GetMask().at(i) != 0);
+    gpu_mask = SharedDeviceTable(mask.GetMask().data(), npixels, mask_vec.data(), *stream);
 
-    // On this engine's stream, like every other operation it issues: the streams are non-blocking, so a
-    // NULL-stream copy is no longer ordered against the kernels that read the mask. Synchronise before
-    // leaving the constructor - mask_vec is a local and the copy must not outlive it.
-    cudaMemcpyAsync(gpu_mask, mask_vec.data(), npixels, cudaMemcpyHostToDevice, *stream);
-    cudaStreamSynchronize(*stream);
-
-    // Setup GPU settings
+    // Setup GPU settings. The current device, not device 0: workers are pinned round-robin across GPUs,
+    // so device 0's SM count can belong to a different card than the one these kernels launch on.
+    int device = 0;
+    cudaGetDevice(&device);
     cudaDeviceProp prop{};
-    cudaGetDeviceProperties(&prop, 0);
+    cudaGetDeviceProperties(&prop, device);
 
     threads = 128;
     blocks = 4 * prop.multiProcessorCount;
@@ -154,7 +152,7 @@ ImageStatistics ImagePreprocessorGPU::Analyze(ImagePreprocessorBuffer &processed
     cudaMemcpyAsync(gpu_stats, cpu_stats.data(), sizeof(ImageStatistics), cudaMemcpyHostToDevice, *stream);
     preprocess_kernel<T> <<< blocks, threads, 0, *stream >>>(
         reinterpret_cast<const T *>(gpu_decompressed_image.get()),
-        gpu_mask,
+        gpu_mask->get(),
         processed_image.getGPUBuffer(),
         gpu_stats,
         sat_value,

image_analysis/image_preprocessing/ImagePreprocessorGPU.h

@@ -5,12 +5,14 @@
 
 #include "ImagePreprocessor.h"
 #include "../indexing/CUDAMemHelpers.h"
+#include "../indexing/CudaSharedTables.h"
 
 class ImagePreprocessorGPU : public ImagePreprocessor {
     std::shared_ptr<CudaStream> stream;
     int threads;
     int blocks;
-    CudaDevicePtr<uint8_t> gpu_mask;
+    // Geometry-only, so one copy per GPU shared with every other engine on it (CudaSharedTables.h).
+    std::shared_ptr<CudaDevicePtr<uint8_t>> gpu_mask;
     CudaDevicePtr<uint8_t> gpu_decompressed_image;
     CudaDevicePtr<ImageStatistics> gpu_stats;