v1.0.0-rc.173 (#83)

* jfjoch_broker: Optional per-dataset authentication - statistics, images and plots can require a bearer token, which jfjoch_viewer supports.
* jfjoch_viewer: Dark mode and a theme-matched colour scheme, a magnifier panel, and simpler contrast and background controls.
* Rugnux: Multiple performance improvements on GPU and CPU (CPU-only processing up to 40% faster, faster image decoding on ARM), with unchanged results.
* Rugnux: `--model` rigid-body refinement runs on the GPU, and the model-validation check is faster and more reliable.
* Rugnux: Improved scaling and merging - error model, outlier rejection, absorption correction and French-Wilson amplitudes now agree more closely with XDS and ctruncate.
* Rugnux: Improved integration - radial background on powder and ice rings, crowded rotation data keep their reflections, and CPU-only builds integrate large unit cells as GPU builds do.
* Rugnux: More robust detector geometry - measured beam centre, X-ray bandwidth and goniometer rate, and geometry refinement accepted only on significant evidence.
* Rugnux: Merged files are written in the standard setting, or in the setting of a reference MTZ, structure-factor mmCIF or model, with its free-R flags.
* Rugnux: Richer report - ice and powder rings, further lattices, superstructure candidates and mosaicity, with warnings worded as prompts to check.
* Rugnux: Clear error messages when a data set needs more GPU or host memory than is available.

Reviewed-on: #83
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>

tests/ParallelForTest.cpp

@@ -4,6 +4,7 @@
 #include <catch2/catch_all.hpp>
 
 #include <algorithm>
+#include <cmath>
 #include <mutex>
 #include <numeric>
 #include <stdexcept>
@@ -104,12 +105,72 @@ TEST_CASE("ParallelFor_SplitDoesNotChangeTheResult", "[ParallelFor]") {
     }
 }
 
+// The blocks depend on n alone: the same tiling of [0, n), block b always the same range, whatever the
+// thread count.
+TEST_CASE("ParallelBlocks_PartitionIgnoresTheThreadCount", "[ParallelFor]") {
+    for (int n: {0, 1, 7, 4095, 4096, 100000, 5000000}) {
+        const int nb = ReductionBlocks(n);
+        CHECK(nb <= MAX_REDUCTION_BLOCKS);
+        std::vector<std::pair<int, int>> reference;
+        for (size_t nthreads: THREAD_COUNTS) {
+            CAPTURE(n, nthreads);
+            std::vector<std::pair<int, int>> range(static_cast<size_t>(nb), {-1, -1});
+            ParallelBlocks(n, nthreads, [&](int b, int lo, int hi) { range[static_cast<size_t>(b)] = {lo, hi}; });
+            int expected_lo = 0;
+            for (const auto &[lo, hi]: range) {
+                CHECK(lo == expected_lo);
+                CHECK(hi > lo);
+                expected_lo = hi;
+            }
+            CHECK(expected_lo == n);
+            if (reference.empty()) reference = range;
+            CHECK(range == reference);
+        }
+    }
+}
+
+// What the blocks are for: a floating-point sum folded per block and added up in block order has the
+// same bits at any thread count. The terms span many decades, so any change of grouping would show.
+TEST_CASE("ParallelBlocks_SumIsTheSameAtAnyThreadCount", "[ParallelFor]") {
+    constexpr int N = 1000003;
+    constexpr int NCELL = 37;
+    std::vector<double> term(N);
+    for (int i = 0; i < N; i++)
+        term[static_cast<size_t>(i)] = std::exp(std::sin(i * 0.37) * 20.0) * (i % 3 == 0 ? -1.0 : 1.0);
+
+    auto blocked_sums = [&](size_t nthreads) {
+        const int nb = ReductionBlocks(N);
+        std::vector<double> part(static_cast<size_t>(nb), 0.0);
+        std::vector<std::vector<double>> cell_part(static_cast<size_t>(nb), std::vector<double>(NCELL, 0.0));
+        ParallelBlocks(N, nthreads, [&](int b, int lo, int hi) {
+            for (int i = lo; i < hi; i++) {
+                part[static_cast<size_t>(b)] += term[static_cast<size_t>(i)];
+                cell_part[static_cast<size_t>(b)][static_cast<size_t>(i % NCELL)] += term[static_cast<size_t>(i)];
+            }
+        });
+        std::vector<double> out(NCELL + 1, 0.0);
+        for (int b = 0; b < nb; b++) {
+            out[NCELL] += part[static_cast<size_t>(b)];
+            for (int c = 0; c < NCELL; c++)
+                out[static_cast<size_t>(c)] += cell_part[static_cast<size_t>(b)][static_cast<size_t>(c)];
+        }
+        return out;
+    };
+
+    const std::vector<double> one = blocked_sums(1);
+    for (size_t nthreads: {size_t{3}, size_t{7}, size_t{32}}) {
+        CAPTURE(nthreads);
+        CHECK(blocked_sums(nthreads) == one);   // bit for bit, not approximately
+    }
+}
+
 // A negative or zero count is a no-op rather than an error - callers pass a computed size.
 TEST_CASE("ParallelFor_DoesNothingForAnEmptyRange", "[ParallelFor]") {
     int calls = 0;
     for (int n: {0, -1, -1000}) {
         ParallelChunks(n, 8, [&](int, int) { calls++; });
         ParallelFor(n, 8, [&](int) { calls++; });
+        ParallelBlocks(n, 8, [&](int, int, int) { calls++; });
     }
     CHECK(calls == 0);
 }