sf-daq/sf_daq_buffer
0
0
Fork 0
mirror of https://github.com/paulscherrerinstitute/sf_daq_buffer.git synced 2026-05-12 10:45:36 +02:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup

Browse Source
This commit is contained in:
mohacsi_i
2021-06-30 14:29:09 +02:00
parent 395fff5da8
commit 99bbb270b7
7 changed files with 123 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jfj-combined/src/JfjFrameWorker.cpp
+41 -70
View File
@@ -1,16 +1,11 @@
#include <cstring>
#include <sstream>
#include "JfjFrameWorker.hpp"
using namespace std;
using namespace buffer_config;
JfjFrameWorker::JfjFrameWorker(const uint16_t port, const uint32_t moduleID,
std::function<void(uint64_t, uint64_t, BufferBinaryFormat&)> callback):
m_moduleID(moduleID), f_push_callback(callback) {
JfjFrameWorker::JfjFrameWorker(const uint16_t port, std::string moduleName, const uint32_t moduleID, std::function<void(uint64_t, uint64_t, BufferBinaryFormat&)> callback):
m_moduleName(moduleName), m_moduleID(moduleID), m_moduleStats(modulename, moduleID, 10.0), f_push_callback(callback) {
m_udp_receiver.bind(port);
m_state = "ON";
}
@@ -18,14 +13,17 @@ JfjFrameWorker::~JfjFrameWorker() {
m_udp_receiver.disconnect();
}
/** Process Packets
Drains the buffer either until it's empty or the current frame is finished.
Has some optimizations and safety checks before segfaulting right away...
TODO: Direct memcopy into FrameCache for more speed! **/
inline uint64_t JfjFrameWorker::process_packets(BufferBinaryFormat& buffer){
//std::cout << " Called process_packets()" << std::endl;
while(!m_buffer.is_empty()){
// Happens if the last packet from the previous frame gets lost.
if (m_frame_index != m_buffer.peek_front().framenum) {
m_frame_index = m_buffer.peek_front().framenum;
if (m_current_index != m_buffer.peek_front().bunchid) [[unlikely]] {
m_current_index = m_buffer.peek_front().bunchid;
if(this->in_progress){
this->in_progress = false;
return buffer.meta.pulse_id;
@@ -34,30 +32,32 @@ inline uint64_t JfjFrameWorker::process_packets(BufferBinaryFormat& buffer){
// Otherwise pop the queue (and set current frame index)
jfjoch_packet_t& c_packet = m_buffer.pop_front();
m_frame_index = c_packet.framenum;
this->in_progress = true;
//std::cout << " ff: " << c_packet.framenum << std::endl;
//std::cout << " ex: " << c_packet.exptime << std::endl;
//std::cout << " pp: " << c_packet.packetnum << std::endl;
// Always copy metadata (otherwise problem when 0th packet gets lost)
buffer.meta.pulse_id = c_packet.bunchid;
buffer.meta.frame_index = c_packet.framenum;
buffer.meta.daq_rec = c_packet.debug;
buffer.meta.module_id = m_moduleID;
// Sanity check: rather throw than segfault...
if(c_packet.packetnum >= JF_N_PACKETS_PER_FRAME) [[unlikely]] {
std::stringstream ss << "Packet index '" << c_packet.packetnum "' is out of range of " << JF_N_PACKETS_PER_FRAME << std::endl;
throw std::range_error(ss.str());
}
// Start new frame
if(!this->in_progress) [[unlikely]] {
m_current_index = c_packet.bunchid;
this->in_progress = true;
// Always copy metadata (otherwise problem when 0th packet gets lost)
buffer.meta.pulse_id = c_packet.bunchid;
buffer.meta.frame_index = c_packet.framenum;
buffer.meta.daq_rec = c_packet.debug;
buffer.meta.module_id = m_moduleID;
}
// Copy data to frame buffer
if(c_packet.packetnum >= JF_N_PACKETS_PER_FRAME){
std::cout << "Too high packet index: " << c_packet.packetnum << std::endl;
return 0;
}
size_t offset = JUNGFRAU_DATA_BYTES_PER_PACKET * c_packet.packetnum;
memcpy( (void*) (buffer.data + offset), c_packet.data, JUNGFRAU_DATA_BYTES_PER_PACKET);
buffer.meta.n_recv_packets++;
// Last frame packet received. Frame finished.
if (c_packet.packetnum == JF_N_PACKETS_PER_FRAME - 1){
// std::cout << "Finished pulse: " << buffer.meta.pulse_id << std::endl;
if (c_packet.packetnum == JF_N_PACKETS_PER_FRAME - 1) [[unlikely]] {
this->in_progress = false;
return buffer.meta.pulse_id;
}
@@ -68,68 +68,39 @@ inline uint64_t JfjFrameWorker::process_packets(BufferBinaryFormat& buffer){
}
uint64_t JfjFrameWorker::get_frame(BufferBinaryFormat& buffer){
//std::cout << "Called get_frame()" << std::endl;
// std::cout << "Called get_frame()" << std::endl;
// Reset the metadata and frame buffer for the next frame. (really needed?)
// Reset the metadata and frame buffer for the next frame
memset(&buffer, 0, sizeof(buffer));
uint64_t pulse_id = 0;
// Process leftover packages in the buffer
if (!m_buffer.is_empty()) {
//std::cout << "Leftovers" << std::endl;
auto pulse_id = process_packets(buffer);
if (pulse_id != 0) { return pulse_id; }
}
// Hehehehe... do-while loop!
do {
// First make sure the buffer is drained of leftovers
pulse_id = process_packets(buffer);
if (pulse_id != 0) [[likely]] { return pulse_id; }
while (true) {
// Receive new packages (pass if none)...
//std::cout << "New packages" << std::endl;
// Then try to refill buffer...
m_buffer.fill_from(m_udp_receiver);
if (m_buffer.is_empty()) { continue; }
// std::cout << "\tGot " << m_buffer.size() << std::endl;
// ... and process them
auto pulse_id = process_packets(buffer);
if (pulse_id != 0) { return pulse_id; }
}
} while (true);
}
void JfjFrameWorker::run(){
std::cout << "Running worker loop" << std::endl;
// Might be better creating a structure for double buffering
BufferBinaryFormat buffer;
uint64_t pulse_id_previous = 0;
uint64_t frame_index_previous = 0;
try{
m_state = "RUNNING";
while (true) {
// NOTE: Needs to be pipelined for really high frame rates
auto pulse_id = get_frame(buffer);
m_stats.record_stats(buffer.meta, true);
if(pulse_id>10){
if(pulse_id>10) [[likely]] {
f_push_callback(pulse_id, m_moduleID, buffer);
}
}
} catch (const std::exception& ex) {
std::cout << "Exception in worker loop: " << ex.what() << std::endl;
m_state = "ERROR";
throw;
};
}
std::string JfjFrameWorker::print() const {
std::string msg = "JungfrauFrameWorker #" + std::to_string(m_moduleID) + "\n"+
"State:\t" + m_state + "\n";
return msg;
}
std::ostream& operator<<(std::ostream& os, const JfjFrameWorker& worker){
os << worker.print() << std::endl;
return os;
}