From 38137e16a0794a31ddf35daded924b355a8a944b Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 18 Nov 2026 16:26:01 +0100 Subject: [PATCH] Live stills: the frames waiting for the analysis inside the image buffer, at most half of it Lane l's hold (702b8d4a6) kept a frame that found no free slot as a heap copy of its compressed bytes, up to the image buffer's size again - up to twice the configured image memory. Now every waiting frame is held as its compressed bytes packed into slots of the image buffer (HoldArena): several frames to a slot, at most half of the slots, the slots kept for the analysis threads to send with left alone; a slot is reused once its frames are gone, and the slots go back before the image buffer is checked at the end. A frame that finds the waiting half full is dropped and counted as before (blocking: waits). The receiver's image memory is the image buffer (image_buffer_MiB of the broker, -B of the stills test) and nothing beside it; the broker takes the same receiver. The frames are no longer serialised into a slot of their own while they wait, so the broker's image routes show a frame once it is analysed. HoldArenaTest: half of the slots at most, three frames of a third of a slot each to a slot, nothing larger than a slot, a freed slot reused, all slots back after ReleaseSlots. jfjoch_fpga_stills_test prints the process's maximum resident memory. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01UqXYdHHZ4cogS1mrGUtfN7 --- docs/JFJOCH_BROKER.md | 9 ++- receiver/HoldArena.h | 90 +++++++++++++++++++++++++ receiver/JFJochReceiverRugnuxStills.cpp | 63 +++++------------ receiver/JFJochReceiverRugnuxStills.h | 11 ++- receiver/StillsPrePass.h | 14 ++-- tests/CMakeLists.txt | 1 + tests/HoldArenaTest.cpp | 40 +++++++++++ tools/jfjoch_fpga_stills_test.cpp | 5 +- 8 files changed, 168 insertions(+), 65 deletions(-) create mode 100644 receiver/HoldArena.h create mode 100644 tests/HoldArenaTest.cpp diff --git a/docs/JFJOCH_BROKER.md b/docs/JFJOCH_BROKER.md index 24599c00f..fcfeda74f 100644 --- a/docs/JFJOCH_BROKER.md +++ b/docs/JFJOCH_BROKER.md @@ -373,9 +373,12 @@ of its frames indexed, as with a small image buffer, a low hit rate or a chip wh cell given), the distance in the header is used for the whole run: this is a warning in the log and a note of the live status, and a wrong header distance then costs resolution and indexed frames. -Frames arriving during the pre-pass, or faster than the analysis, wait in the image buffer, in all its slots but -one per analysis thread, kept for sending; a frame that finds it full is dropped and counted as for a full image -buffer, so analysis slower than the frame rate costs frames, not memory. Where the writer lags behind, the analysis +Frames arriving during the pre-pass, or faster than the analysis, wait in the image buffer as their compressed bytes, +packed into at most half of its slots (several frames to a slot); the other half is for the analysed frames, which go +to the writer from a slot each, with one slot kept per analysis thread. The receiver's image memory is the image +buffer (`image_buffer_MiB`, `-B` of `jfjoch_fpga_stills_test`) and nothing beside it. A frame that finds the waiting +half full is dropped and counted as for a full image buffer, so analysis slower than the frame rate costs frames, +not memory. Where the writer lags behind, the analysis waits for slots to come back. A pre-pass that fails leaves the stated geometry and mask in use. Where the start message cannot be sent after the pre-pass (no writer listening) or the analysis cannot be set up, the collection ends with that error, reported by `/status` and `/wait_till_done`, and the diff --git a/receiver/HoldArena.h b/receiver/HoldArena.h new file mode 100644 index 000000000..ebfeaf5b7 --- /dev/null +++ b/receiver/HoldArena.h @@ -0,0 +1,90 @@ +// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#pragma once + +#include +#include +#include +#include + +#include "../common/ImageBuffer.h" +#include "../common/ZeroCopyReturnValue.h" + +// The frames waiting for the analysis, as their compressed bytes packed into slots of the image buffer: inside its +// memory, at most `max_slots` of its slots (half of them in the stills receiver), and the slots kept free for sending +// left alone. A slot is reused once the frames in it are all released; with every slot taken and full, Allocate fails. +class HoldArena { + struct Chunk { + ZeroCopyReturnValue *slot; + size_t used = 0; + int64_t frames = 0; + }; + ImageBuffer &image_buffer; + const int64_t max_slots; + const int64_t keep_free; + const size_t slot_size; + std::mutex m; + std::vector chunks; + size_t current = SIZE_MAX; +public: + struct Region { + uint8_t *data = nullptr; + std::function release; // once the frame is gone + }; + + HoldArena(ImageBuffer &in_image_buffer, int64_t in_max_slots, int64_t in_keep_free, size_t in_slot_size) + : image_buffer(in_image_buffer), max_slots(in_max_slots), keep_free(in_keep_free), slot_size(in_slot_size) {} + + ~HoldArena() { ReleaseSlots(); } + + // The slots go back to the image buffer: once no frame is held any more + void ReleaseSlots() { + std::unique_lock ul(m); + for (auto &c: chunks) + if (c.slot) { + c.slot->discard(); + c.slot = nullptr; + } + current = SIZE_MAX; + } + + // Empty where there is no room + Region Allocate(size_t size) { + std::unique_lock ul(m); + if (size > slot_size) + return {}; + if (current == SIZE_MAX || chunks[current].used + size > slot_size) { + current = SIZE_MAX; + for (size_t i = 0; i < chunks.size(); i++) + if (chunks[i].slot && chunks[i].frames == 0) { + chunks[i].used = 0; + current = i; + break; + } + if (current == SIZE_MAX && static_cast(chunks.size()) < max_slots) { + if (auto slot = image_buffer.GetImageSlot(keep_free)) { + chunks.push_back(Chunk{.slot = slot}); + current = chunks.size() - 1; + } + } + if (current == SIZE_MAX) + return {}; + } + Chunk &c = chunks[current]; + Region ret{.data = static_cast(c.slot->GetImage()) + c.used}; + c.used += size; + c.frames++; + const size_t index = current; + ret.release = [this, index] { + std::unique_lock ul2(m); + chunks[index].frames--; + }; + return ret; + } + + int64_t GetSlotsUsed() { + std::unique_lock ul(m); + return static_cast(chunks.size()); + } +}; diff --git a/receiver/JFJochReceiverRugnuxStills.cpp b/receiver/JFJochReceiverRugnuxStills.cpp index a4133b54a..d9ed53f50 100644 --- a/receiver/JFJochReceiverRugnuxStills.cpp +++ b/receiver/JFJochReceiverRugnuxStills.cpp @@ -52,8 +52,10 @@ JFJochReceiverRugnuxStills::~JFJochReceiverRugnuxStills() { void JFJochReceiverRugnuxStills::OnStart(std::chrono::steady_clock::time_point received) { const int64_t slots = image_buffer.GetStatus().total_slots; - stills_keep_free = std::min(stills_nthreads, slots / 2); - copy_budget = slots * experiment.GetImageBufferLocationSize(); + // The frames that wait take at most half of the image buffer; the other half is for those analysed, sent from + // a slot each, and a slot is kept free for each analysis thread to send with + const int64_t keep_free = std::min(stills_nthreads, slots / 2); + hold_arena = std::make_unique(image_buffer, slots / 2, keep_free, experiment.GetImageBufferLocationSize()); const StartMessage start = MakeStartMessage(experiment, pixel_mask, *az_int_mapping); // The frames are shown from their arrival, on the stated geometry until the pre-pass has decided its own. // To the image buffer only: the writer and the ZeroMQ streams get the one start message, after the pre-pass. @@ -93,59 +95,24 @@ void JFJochReceiverRugnuxStills::OnImage(uint32_t id, DataMessage &message, std: } const size_t size = message.image.GetCompressedSize(); - // Waits for the analysis in a slot of the image buffer, where it can be seen while it waits (it is not sent from - // there); a slot is kept free for each analysis thread to send with. Without a slot, in a copy of its own. + // Waits for the analysis as its compressed bytes, packed into slots of the image buffer (HoldArena) auto held = std::make_shared(); - const auto hold = [&] { - held->slot = image_buffer.GetImageSlot(stills_keep_free); - if (held->slot == nullptr) { - if (copy_bytes.fetch_add(static_cast(size)) + static_cast(size) <= copy_budget) { - held->copy.assign(message.image.GetCompressed(), message.image.GetCompressed() + size); - held->copy_bytes = ©_bytes; - } else - copy_bytes -= static_cast(size); - } - return held->slot != nullptr || held->copy_bytes != nullptr; - }; - bool held_ok = hold(); - while (!held_ok && image_puller.IsBlocking() && !cancelled) { + HoldArena::Region region = hold_arena->Allocate(size); + while (!region.data && image_puller.IsBlocking() && !cancelled) { std::this_thread::sleep_for(std::chrono::milliseconds(1)); - held_ok = hold(); + region = hold_arena->Allocate(size); } - if (!held_ok) { + if (!region.data) { writer_queue_full = true; return; } + memcpy(region.data, message.image.GetCompressed(), size); + held->release = std::move(region.release); held->message = message; StampImage(held->message, image_puller.GetCurrentFifoUtilization()); - - if (held->slot) { - // In the slot as an image without analysis; the analysis reads the image where it is in the slot. - auto slot_buffer = static_cast(held->slot->GetImage()); - CBORStream2Serializer serializer(slot_buffer, experiment.GetImageBufferLocationSize()); - held->message.image = CompressedImage(nullptr, 0, message.image.GetWidth(), message.image.GetHeight(), - message.image.GetMode(), message.image.GetCompressionAlgorithm(), - message.image.GetChannel()); - serializer.SerializeImage(held->message); - const size_t image_offset = serializer.GetImageAppendOffset(); - if (image_offset + size + 32 >= static_cast(experiment.GetImageBufferLocationSize())) { - logger.Error("Dropping image {} - metadata {} B + image {} B do not fit in buffer slot {} B", message.number, - image_offset, size, experiment.GetImageBufferLocationSize()); - return; - } - memcpy(slot_buffer + image_offset, message.image.GetCompressed(), size); - serializer.AppendImage(size); - held->message.image = CompressedImage(slot_buffer + image_offset, size, message.image.GetWidth(), - message.image.GetHeight(), message.image.GetMode(), - message.image.GetCompressionAlgorithm(), message.image.GetChannel()); - held->slot->SetImageNumber(message.number); - held->slot->SetImageSize(serializer.GetBufferSize()); - held->slot->SetIndexed(false); - held->slot->ReadyToSend(); - } else - held->message.image = CompressedImage(held->copy.data(), size, message.image.GetWidth(), - message.image.GetHeight(), message.image.GetMode(), - message.image.GetCompressionAlgorithm(), message.image.GetChannel()); + held->message.image = CompressedImage(region.data, size, message.image.GetWidth(), message.image.GetHeight(), + message.image.GetMode(), message.image.GetCompressionAlgorithm(), + message.image.GetChannel()); stills->Hold(held); } @@ -159,6 +126,8 @@ void JFJochReceiverRugnuxStills::FinishCollection() { } catch (const std::exception &) { error = std::current_exception(); } + // Every frame is analysed: the slots the frames waited in go back, before the image buffer is checked + hold_arena->ReleaseSlots(); current_status.SetProgress(1.0); current_status.SetStatus(GetStatus()); diff --git a/receiver/JFJochReceiverRugnuxStills.h b/receiver/JFJochReceiverRugnuxStills.h index b43f1b4c4..7227e2fe4 100644 --- a/receiver/JFJochReceiverRugnuxStills.h +++ b/receiver/JFJochReceiverRugnuxStills.h @@ -9,6 +9,7 @@ #include "JFJochReceiverStream.h" #include "RugnuxLiveStatus.h" +#include "HoldArena.h" #include "StillsGPUAnalysis.h" // A serial collection analysed frame by frame at the geometry of a pre-pass, which the start message waits for @@ -21,12 +22,10 @@ class JFJochReceiverRugnuxStills : public JFJochReceiverStream, public StillsSin IndexerThreadPool *const indexing_thread_pool; const int64_t stills_nthreads; - int64_t stills_keep_free = 0; // slots frames do not take, for the analysis threads to send with - // Frames that find no free slot while they wait for the analysis are held as their compressed bytes, up to the - // image buffer's size again: the pre-pass holds every frame that arrives before it is over, and a frame is a - // fraction of a slot (1.5 MB of a 24 MB slot on a 9M detector) - int64_t copy_budget = 0; - std::atomic copy_bytes = 0; + // The frames waiting for the analysis, packed as their compressed bytes into at most half of the image + // buffer's slots: a frame is a fraction of a slot (1.5 MB of a 24 MB slot on a 9M detector), and the pre-pass + // holds every frame that arrives before it is over + std::unique_ptr hold_arena; std::mutex stills_mutex; bool cut = false; diff --git a/receiver/StillsPrePass.h b/receiver/StillsPrePass.h index 5f6712c15..b82ce058f 100644 --- a/receiver/StillsPrePass.h +++ b/receiver/StillsPrePass.h @@ -4,6 +4,7 @@ #pragma once #include +#include #include #include #include @@ -15,14 +16,13 @@ #include "../common/ZeroCopyReturnValue.h" #include "../image_analysis/IndexAndRefine.h" // StillsWindow -// An image held until analysed, pointing into `slot`, which goes back unsent with the last copy. The slot is -// forgotten then, so that the copy sent with the analysis is the only one the image buffer finds. Where no slot -// was free, the image points into `copy` instead, its compressed bytes, counted in `copy_bytes` while held. +// An image held until analysed, pointing into `slot`, which goes back unsent with the last copy (the slot is +// forgotten then, so that the copy sent with the analysis is the only one the image buffer finds), or into bytes +// `release` gives back with the last copy (HoldArena). struct HeldImage { DataMessage message; ZeroCopyReturnValue *slot = nullptr; - std::vector copy; - std::atomic *copy_bytes = nullptr; + std::function release; HeldImage() = default; HeldImage(const HeldImage &) = delete; @@ -30,8 +30,8 @@ struct HeldImage { ~HeldImage() { if (slot) slot->discard(); - if (copy_bytes) - *copy_bytes -= static_cast(copy.size()); + if (release) + release(); } }; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index a48a4ac86..3ae22959c 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -156,6 +156,7 @@ ADD_EXECUTABLE(jfjoch_test JFJochReceiverRugnuxTest.cpp FPGAImagePullerTest.cpp StillsSelectionTest.cpp + HoldArenaTest.cpp GridScanSettingsTest.cpp JFJochReceiverPlotsTest.cpp GoniometerAxisTest.cpp diff --git a/tests/HoldArenaTest.cpp b/tests/HoldArenaTest.cpp new file mode 100644 index 000000000..e9414d4dc --- /dev/null +++ b/tests/HoldArenaTest.cpp @@ -0,0 +1,40 @@ +// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#include + +#include "../receiver/HoldArena.h" + +TEST_CASE("HoldArena_WithinHalfOfTheImageBuffer", "[HoldArena]") { + constexpr size_t slot_size = 1024 * 1024; + ImageBuffer buffer(64 * slot_size); + buffer.StartMeasurement(slot_size); + const int64_t total = buffer.GetStatus().total_slots; + REQUIRE(total >= 32); + + std::vector held; + { + HoldArena arena(buffer, total / 2, 4, slot_size); + // Frames of a third of a slot: three to a slot, half of the slots at most + while (true) { + auto r = arena.Allocate(slot_size / 3); + if (!r.data) + break; + held.push_back(std::move(r)); + } + CHECK(arena.GetSlotsUsed() == total / 2); + CHECK(held.size() == static_cast(3 * (total / 2))); + CHECK(buffer.GetSlotStatus().available_slots == total - total / 2); + // Larger than a slot: never held + CHECK(!arena.Allocate(slot_size + 1).data); + + // A slot whose frames are all gone is reused, nothing more is taken from the buffer + for (int i = 0; i < 3; i++) + held[i].release(); + CHECK(arena.Allocate(slot_size / 3).data != nullptr); + CHECK(arena.GetSlotsUsed() == total / 2); + + arena.ReleaseSlots(); + CHECK(buffer.GetSlotStatus().available_slots == total); + } +} diff --git a/tools/jfjoch_fpga_stills_test.cpp b/tools/jfjoch_fpga_stills_test.cpp index 46f20f0bb..38cf67851 100644 --- a/tools/jfjoch_fpga_stills_test.cpp +++ b/tools/jfjoch_fpga_stills_test.cpp @@ -258,9 +258,10 @@ bool RunDataset(Logger &logger, AcquisitionDeviceGroup &aq_devices, const std::s output.status.images_dropped, output.efficiency); logger.Info("Delivered {:.1f} Hz (first to last image {:.2f} s), source blocked {:.1f}% of it", delivered_hz, delivery_s, 100.0 * blocked); - logger.Info("Sustained {:.1f} Hz (images / wall time {:.2f} s, start to analysis done) CPU {:.1f} s = {:.1f} cores", + logger.Info("Sustained {:.1f} Hz (images / wall time {:.2f} s, start to analysis done) CPU {:.1f} s = {:.1f} cores" + " max resident memory {:.1f} GiB", static_cast(output.status.images_collected) / wall_time, wall_time, cpu_time, - cpu_time / wall_time); + cpu_time / wall_time, static_cast(usage_end.ru_maxrss) / (1024.0 * 1024.0)); // The card's own count of the cycles (200 MHz) it waited for a host buffer, i.e. was held by the host for (int i = 0; i < x.GetDataStreamsNum(); i++) { const auto status = aq_devices[i].GetDataCollectionStatus();