Live stills hold: frames in a slot of their own in a quarter of the image buffer, seen while they wait

38137e16a packed every waiting frame into the hold, so a frame was no longer in
the image buffer by its number until analysed (JFJochReceiverRugnux_Stills_
ImagesVisibleDuringPrePass failed). The waiting half of the image buffer is now
split: up to a quarter of the slots hold a frame each, serialised there as
before (the image routes find it), the rest of the half packs frames as their
compressed bytes (HoldArena). The bound is unchanged: at most half of the image
buffer, nothing beside it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UqXYdHHZ4cogS1mrGUtfN7
This commit is contained in:
leonarski_fandClaude Opus 5.5 committed 2026-11-18 17:10:32 +01:00
1 parent deb4eee165
commit 4c9cc48382
3 files changed
+65 -18

No files matched your search

+4 -3
View File
@@ -373,9 +373,10 @@ 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 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
Frames arriving during the pre-pass, or faster than the analysis, wait in at most half of the image buffer: a quarter
of its slots hold a frame each (it can be seen through the image routes while it waits), the rest of that half
holds frames as their compressed bytes, several 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
+55 -12
View File
@@ -54,8 +54,10 @@ void JFJochReceiverRugnuxStills::OnStart(std::chrono::steady_clock::time_point r
const int64_t slots = image_buffer.GetStatus().total_slots;
// 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<HoldArena>(image_buffer, slots / 2, keep_free, experiment.GetImageBufferLocationSize());
stills_keep_free = std::min(stills_nthreads, slots / 2);
visible_max = slots / 4;
hold_arena = std::make_unique<HoldArena>(image_buffer, slots / 2 - visible_max, stills_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.
@@ -90,26 +92,67 @@ void JFJochReceiverRugnuxStills::OnImage(uint32_t id, DataMessage &message, std:
CountImage(message);
const size_t size = message.image.GetCompressedSize();
// Waits for the analysis as its compressed bytes, packed into slots of the image buffer (HoldArena)
// Waits for the analysis in half of the image buffer at most: in a slot of its own, where it can be seen while it
// waits (it is not sent from there), in up to half of those slots; else as its compressed bytes, packed with
// others into the rest (HoldArena)
auto held = std::make_shared<HeldImage>();
HoldArena::Region region = hold_arena->Allocate(size);
while (!region.data && image_puller.IsBlocking() && !cancelled) {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
HoldArena::Region region;
const auto hold = [&] {
if (visible_held.fetch_add(1) < visible_max) {
held->slot = image_buffer.GetImageSlot(stills_keep_free);
if (held->slot) {
held->release = [this] { --visible_held; };
return true;
}
}
--visible_held;
region = hold_arena->Allocate(size);
return region.data != nullptr;
};
bool held_ok = hold();
while (!held_ok && image_puller.IsBlocking() && !cancelled) {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
held_ok = hold();
}
if (!region.data) {
if (!held_ok) {
writer_queue_full = true;
return;
}
memcpy(region.data, message.image.GetCompressed(), size);
held->release = std::move(region.release);
// Not chosen (stills_downsample): written as it came, without its analysis
held->analyse = StillsImageSelected(message.number, downsample, StillsGPUAnalysis::PREPASS_MAX_IMAGES);
held->message = message;
StampImage(held->message, image_puller.GetCurrentFifoUtilization());
held->message.image = CompressedImage(region.data, size, message.image.GetWidth(), message.image.GetHeight(),
message.image.GetMode(), message.image.GetCompressionAlgorithm(),
message.image.GetChannel());
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<uint8_t *>(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<size_t>(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 {
memcpy(region.data, message.image.GetCompressed(), size);
held->release = std::move(region.release);
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);
}
+6 -3
View File
@@ -22,9 +22,12 @@ class JFJochReceiverRugnuxStills : public JFJochReceiverStream, public StillsSin
IndexerThreadPool *const indexing_thread_pool;
const int64_t stills_nthreads;
// 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
// The frames waiting for the analysis take at most half of the image buffer's slots: a quarter as a slot each,
// the rest packed as their compressed bytes (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)
int64_t stills_keep_free = 0; // slots frames do not take, for the analysis threads to send with
int64_t visible_max = 0;
std::atomic<int64_t> visible_held = 0;
std::unique_ptr<HoldArena> hold_arena;
std::mutex stills_mutex;