leonarski_fandClaude Opus 5.5
9137f28939
JFJochReceiverFPGA and JFJochReceiverRugnuxStills read three slot counters for each image through
GetStatus, which walks every slot under the buffer mutex, lists the image numbers and sorts them. With a
buffer sized for 2 kHz (thousands of slots) that is about a core of CPU and time on the mutex every
other buffer user needs. GetSlotStatus returns only the counters; GetStatus stays for the HTTP status.
On rc184 the per-image readers are JFJochReceiverFPGA's FrameTransformationThread and its GPUSink (the live-stills path).
(ported from rc184-2 4907014e4)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HVeDQsU5a8AJUdJPgWevAK
98 lines
3.1 KiB
C++
98 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);
|
|
|
|
ZeroCopyReturnValue *GetImageSlot();
|
|
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);
|
|
|
|
// Only the slot counters, no image list: cheap enough to call for every image
|
|
ImageBufferStatus GetSlotStatus() const;
|
|
ImageBufferStatus GetStatus() const;
|
|
};
|