Files
leonarski_fandClaude Opus 5.5 d8f41a488f Card summation of 128 frames or more: packets of a module counted on the host
The card counts the packets of a summed module in 16 bits (axis_completion
packet_count, hls_jfjoch.h), 512 per frame, so from 128 summed frames the
count wraps: at 128 and 256 to exactly 0, which the host took for a module
not collected (IsAnyPacketCollected), so every image was lost; between them
the efficiency came out wrong. Where 512 * card summation exceeds 16 bits,
the host now counts the packets from the module's packet mask (the packets
present in all of its frames) times the summation, and keeps the count in 32
bits (Completion, AcquisitionCounters). Exact for complete modules; with
packets lost in some frames it counts only those present in all. The mock of
the card keeps the card's 16-bit count, so it shows the same wrap (checked:
without this, summation 256 on the mock delivers no image).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HVeDQrPqZ52Tp6rzzZGxf3
2026-11-18 18:49:54 +01:00

227 lines
9.2 KiB
C++

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#include <thread>
#include "AcquisitionCounters.h"
#include "../common/JFJochException.h"
AcquisitionCounters::AcquisitionCounters()
: total_packets(0), slowest_frame_number(0), fastest_frame_number(0),
curr_frame_number(max_modules, 0), acquisition_finished(false), expected_frames(0) {}
void AcquisitionCounters::Reset(const DiffractionExperiment &experiment, uint16_t data_stream) {
std::unique_lock ul(m);
acquisition_finished = false;
slowest_frame_number = 0;
fastest_frame_number = 0;
if ((experiment.GetDetectorMode() == DetectorMode::PedestalG0) ||
(experiment.GetDetectorMode() == DetectorMode::PedestalG1) ||
(experiment.GetDetectorMode() == DetectorMode::PedestalG2))
expected_frames = experiment.GetFrameNum();
else
expected_frames = experiment.GetFrameNum() / experiment.GetFPGASummation();
nmodules = experiment.GetModulesNum(data_stream);
if (nmodules > max_modules)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Acquisition counter cannot support that many modules");
for (int i = 0; i < max_modules; i++)
curr_frame_number[i] = 0;
handle_for_frame = std::vector<uint64_t>(expected_frames * nmodules, HandleNotFound);
packets_collected = std::vector<uint32_t>(expected_frames * nmodules);
packets_per_module = std::vector<uint64_t>(nmodules);
total_packets = 0;
expected_packets_per_module = 512 * experiment.GetFPGASummation();
if (experiment.GetBitDepthReadout() == 32)
bytes_per_packet = 4096LU;
else if (experiment.GetBitDepthReadout() == 8)
bytes_per_packet = 1024LU; // Need to seriously refactor, to have expected_packets_per_module specific for detector
else
bytes_per_packet = 2048LU;
}
void AcquisitionCounters::UpdateCounters(const Completion *c) {
std::unique_lock ul(m);
if (c->module_number >= nmodules)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"UpdateCounters wrong module number: " + std::to_string(c->module_number) + " for frame " + std::to_string(c->frame_number) +
" and handle " + std::to_string(c->handle));
if (c->frame_number >= expected_frames)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"UpdateCounters frame number is out of bounds");
if (curr_frame_number.at(c->module_number) < c->frame_number)
curr_frame_number.at(c->module_number) = c->frame_number;
if (c->frame_number > slowest_frame_number) {
slowest_frame_number = curr_frame_number[0];
for (int i = 1; i < nmodules; i++)
if (curr_frame_number[i] < slowest_frame_number)
slowest_frame_number = curr_frame_number[i];
}
if (c->frame_number > fastest_frame_number) {
fastest_frame_number = c->frame_number;
}
if (fastest_frame_number - slowest_frame_number > ThresholdFramesLost)
slowest_frame_number = fastest_frame_number - ThresholdFramesLost;
packets_collected.at(c->frame_number * nmodules + c->module_number) = c->packet_count;
handle_for_frame.at(c->frame_number * nmodules + c->module_number) = c->handle;
total_packets += c->packet_count;
packets_per_module[c->module_number] += c->packet_count;
data_updated.notify_all();
}
void AcquisitionCounters::SetAcquisitionFinished() {
std::unique_lock ul(m);
acquisition_finished = true;
data_updated.notify_all();
}
uint64_t AcquisitionCounters::GetBufferHandle(size_t frame, uint16_t module_number) const {
std::shared_lock sl(m);
if (frame >= expected_frames)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"GetBufferHandle Wrong frame number: " + std::to_string(frame));
if (module_number >= nmodules)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"GetBufferHandle Wrong module number: " + std::to_string(module_number)
+ " for frame " + std::to_string(frame));
return handle_for_frame.at(frame * nmodules + module_number);
}
uint64_t AcquisitionCounters::GetBufferHandleAndClear(size_t frame, uint16_t module_number) {
std::unique_lock ul(m);
if (frame >= expected_frames)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"GetBufferHandleAndClear Wrong frame number: " + std::to_string(frame));
if (module_number >= nmodules)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"GetBufferHandleAndClear Wrong module number: " + std::to_string(module_number)
+ " for frame " + std::to_string(frame));
uint64_t ret_val = handle_for_frame.at(frame * nmodules + module_number);
handle_for_frame.at(frame * nmodules + module_number) = HandleNotFound;
return ret_val;
}
uint64_t AcquisitionCounters::GetCurrFrameNumber(uint16_t module_number) const {
if (module_number >= max_modules)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"GetCurrFrameNumber Wrong module number: " + std::to_string(module_number));
std::shared_lock sl(m);
return curr_frame_number[module_number];
}
uint64_t AcquisitionCounters::GetSlowestFrameNumber() const {
std::shared_lock sl(m);
return slowest_frame_number;
}
uint64_t AcquisitionCounters::GetFastestFrameNumber() const {
std::shared_lock sl(m);
return fastest_frame_number;
}
void AcquisitionCounters::WaitForFrame(size_t curr_frame, uint16_t module_number) const {
if (curr_frame == 0)
curr_frame = 1; // Cannot wait for frame 0, as this is initial value
std::shared_lock sl(m);
data_updated.wait(sl, [&] {
const uint64_t head = (module_number == UINT16_MAX)
? slowest_frame_number
: curr_frame_number.at(module_number);
return acquisition_finished || (head >= curr_frame);
});
}
int64_t AcquisitionCounters::CalculateDelay(size_t curr_frame, uint16_t module_number) const {
std::shared_lock sl(m);
const uint64_t head = (module_number == UINT16_MAX)
? slowest_frame_number
: curr_frame_number.at(module_number);
if (head < curr_frame)
return 0;
return static_cast<int64_t>(head - curr_frame);
}
bool AcquisitionCounters::IsAcquisitionFinished() const {
std::shared_lock sl(m);
return acquisition_finished;
}
bool AcquisitionCounters::IsFullModuleCollected(size_t frame, uint16_t module_number) const {
std::shared_lock sl(m);
if (frame >= expected_frames)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"IsFullModuleCollected Wrong frame number: " + std::to_string(frame));
if (module_number >= nmodules)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"IsFullModuleCollected Wrong module number: " + std::to_string(module_number)
+ " for frame " + std::to_string(frame));
return packets_collected[frame * nmodules + module_number] == expected_packets_per_module;
}
bool AcquisitionCounters::IsAnyPacketCollected(size_t frame, uint16_t module_number) const {
std::shared_lock sl(m);
if (frame >= expected_frames)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"IsFullModuleCollected Wrong frame number: " + std::to_string(frame));
if (module_number >= nmodules)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"IsFullModuleCollected Wrong module number: " + std::to_string(module_number)
+ " for frame " + std::to_string(frame));
return packets_collected[frame * nmodules + module_number] > 0;
}
uint64_t AcquisitionCounters::GetTotalPackets() const {
std::shared_lock sl(m);
return total_packets;
}
uint64_t AcquisitionCounters::GetTotalPackets(uint16_t module_number) const {
std::shared_lock sl(m);
if (module_number >= nmodules)
throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
"GetTotalPackets Wrong module number: " + std::to_string(module_number));
return packets_per_module[module_number];
}
uint64_t AcquisitionCounters::GetExpectedPacketsPerImage() const {
return expected_packets_per_module * nmodules;
}
uint64_t AcquisitionCounters::GetTotalExpectedPackets() const {
return GetTotalExpectedPacketsPerModule() * nmodules;
}
uint64_t AcquisitionCounters::GetTotalExpectedPacketsPerModule() const {
std::shared_lock sl(m);
return expected_frames * expected_packets_per_module;
}
uint64_t AcquisitionCounters::GetModuleNumber() const {
std::shared_lock sl(m);
return nmodules;
}
uint64_t AcquisitionCounters::GetBytesReceived() const {
std::shared_lock sl(m);
return total_packets * bytes_per_packet;
}