With rugnux live mode on, a serial collection from a DECTRIS detector now runs the whole live stills workflow instead of per-image analysis only: the frames wait in the image buffer for a pre-pass that fixes the beam centre, distance and mask, are analysed on the GPU at that geometry, and are merged at half and three quarters of the images and after the last. With a model, it is placed, mapped and refined on each merge. The start message waits for the pre-pass, the end message carries the merged data, and /rugnux/status and the frontend report the run. The receiver uses only what a puller delivers, a DataMessage with a compressed image, so a later FPGA puller feeds the same code. FPGA users lose this until that puller exists: JFJochReceiverFPGA has no stills path any more, so a JUNGFRAU or PSI EIGER collection with rugnux on runs image by image on the card's results, as with the mode off, with /rugnux/status idle, no pre-pass and no live merge. From a stream there are no module packets: efficiency is the images received over those expected, a frame not delivered leaves no entry, and per-image collection efficiency, ADU histograms and pulse IDs are absent. The dark frames of the mask sequence always stay with JFJochReceiverLite. Selection used to look only at the goniometer, so POST /pedestal after a rotation /start with rugnux on went to the rugnux receiver and returned an empty mask. Frames numbered outside the collection are dropped: the analysis keeps per-image results by number, and they corrupted the heap. Carries the behaviour of the live commits of rc184, updated for this receiver: the geometry fixed when the pre-pass ends (the running refinement is removed), the q range fixed, the pre-pass holding more frames until the geometry can be fitted, frames arriving during it waiting in the whole image buffer, the indexer pool's device memory report, the stills model step on provisional merges and after the last image, /cancel cutting it, and the model and Mol* viewer of a serial run during the collection. Rotation on this receiver is unchanged: end to end, the old and new receiver wrote a byte-identical MTZ. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
97 lines
3.1 KiB
C++
97 lines
3.1 KiB
C++
// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include "ThreadSafeFIFO.h"
|
|
#include "DiffractionExperiment.h"
|
|
|
|
class ZeroCopyReturnValue;
|
|
|
|
enum class ImageBufferEntryStatus {Empty, InPreparation, Sending, Idle};
|
|
|
|
struct ImageBufferStatus {
|
|
std::vector<int64_t> images_in_the_buffer;
|
|
int64_t min_image_number;
|
|
int64_t max_image_number;
|
|
|
|
int64_t total_slots;
|
|
int64_t available_slots;
|
|
int64_t preparation_slots;
|
|
int64_t sending_slots;
|
|
std::optional<int64_t> current_counter;
|
|
};
|
|
|
|
struct ImageBufferEntry {
|
|
int64_t image_number = -1;
|
|
size_t image_size = 0;
|
|
int64_t readers = 0;
|
|
ImageBufferEntryStatus status = ImageBufferEntryStatus::Empty;
|
|
bool indexed = false;
|
|
};
|
|
|
|
class ImageBuffer {
|
|
mutable std::mutex m;
|
|
std::condition_variable cv_preview_done;
|
|
std::condition_variable cv_preparation_done;
|
|
std::condition_variable cv_send_done;
|
|
uint8_t *buffer;
|
|
const size_t buffer_size;
|
|
|
|
size_t slot_size = 0;
|
|
int64_t slot_count = 0;
|
|
|
|
std::queue<uint32_t> free_slots;
|
|
std::vector<ImageBufferEntry> v;
|
|
std::vector<ZeroCopyReturnValue> send_buffer_zero_copy_ret_val;
|
|
int64_t slots_preparation = 0;
|
|
int64_t slots_sending = 0;
|
|
int64_t slots_in_preview = 0;
|
|
int64_t slots_idle = 0;
|
|
|
|
bool disable_requests = true; // All requests fail in this state
|
|
int64_t counter = 0; // Counter is increased when something changes in the image buffer
|
|
|
|
std::mutex start_message_mutex;
|
|
std::vector<uint8_t> start_message;
|
|
|
|
// Assumes existing lock
|
|
bool FinalizeInternal(std::unique_lock<std::mutex> &ul,
|
|
std::chrono::microseconds timeout = std::chrono::milliseconds(2500));
|
|
|
|
std::optional<uint32_t> getHandle(int64_t image_number) const;
|
|
std::optional<uint32_t> getHandleMaxImage() const;
|
|
std::optional<uint32_t> getHandleMaxIndexedImage() const;
|
|
|
|
uint8_t *GetBufferLocation(size_t id); // image metadata + image
|
|
public:
|
|
constexpr static int64_t MaxImage = -1;
|
|
constexpr static int64_t MaxIndexedImage = -2;
|
|
|
|
explicit ImageBuffer(size_t buffer_size_bytes);
|
|
~ImageBuffer();
|
|
ImageBuffer(const ImageBuffer &) = delete;
|
|
ImageBuffer &operator=(const ImageBuffer &) = delete;
|
|
|
|
void StartMeasurement(size_t buffer_location_size);
|
|
void StartMeasurement(const DiffractionExperiment& experiment);
|
|
|
|
// Nullptr where no more than `keep_free` slots are free.
|
|
ZeroCopyReturnValue *GetImageSlot(int64_t keep_free = 0);
|
|
void ReadyToSend(uint32_t location, int64_t image_number, size_t image_size, bool indexed);
|
|
void ReleaseSlot(uint32_t location);
|
|
|
|
int64_t GetAvailSlots() const;
|
|
size_t GetBufferSize() const;
|
|
|
|
bool CheckIfBufferReturned(std::chrono::microseconds timeout);
|
|
bool Finalize(std::chrono::microseconds timeout);
|
|
|
|
bool GetImage(std::vector<uint8_t> &out_v, int64_t image_number = MaxImage);
|
|
|
|
void SaveStartMessage(const std::vector<uint8_t> &msg);
|
|
void GetStartMessage(std::vector<uint8_t> &out_v);
|
|
|
|
ImageBufferStatus GetStatus() const;
|
|
};
|