119 static int produce_call_count = 0;
120 produce_call_count++;
121 ldmx_log(debug) <<
"produce() called, count=" << produce_call_count;
122 ldmx_log(debug) <<
"verbose_parse=" << (m_verbose_parse_ ?
"true" :
"false");
123 if (m_verbose_parse_ || produce_call_count <= 3) {
124 ldmx_log(info) <<
"produce() call #" << produce_call_count;
128 m_event_start_time_ = std::chrono::steady_clock::now();
131 uint32_t current_event_errors = 0;
133 while (m_reader_ && !m_reader_.
eof()) {
136 frame_header.
read(m_reader_);
139 const long long frame_end =
140 static_cast<long long>(m_reader_.
tell()) + frame_header.
size();
145 if (m_verbose_parse_)
146 ldmx_log(debug) <<
"skipping non-data frame (channel="
147 << frame_header.
channel() <<
")";
148 m_reader_.
seek(frame_end);
154 bool parsed_ok =
false;
158 int pos_before_ror = m_reader_.
tell();
162 ror_header.
read(m_reader_);
163 if (!ror_header.
valid())
throw std::runtime_error(
"invalid RoR header");
165 fragment.header_.subsystem_id_ =
166 static_cast<uint64_t
>(ror_header.
subsystem());
167 fragment.header_.contributor_id_ =
169 fragment.header_.timestamp_ = ror_header.
timestamp();
170 fragment.header_.flags_ = ror_header.
flags();
172 if (m_verbose_parse_) {
173 ldmx_log(debug) <<
"parsed RoR header subsys="
180 std::vector<uint8_t> payload_data;
181 long long payload_size = frame_end - m_reader_.
tell();
182 if (payload_size > 0) {
183 payload_data.resize(payload_size);
184 m_reader_.
read(
reinterpret_cast<char*
>(payload_data.data()),
187 fragment.payload_ = std::move(payload_data);
191 if (m_verbose_parse_)
193 <<
"RoR header parse failed, trying packing subsystem format";
195 m_reader_.
seek(pos_before_ror);
203 fragment.header_.subsystem_id_ =
static_cast<uint64_t
>(pkt.id());
204 fragment.header_.contributor_id_ =
206 fragment.header_.timestamp_ =
static_cast<uint64_t
>(pkt.
header()[1]) *
210 const auto& data = pkt.
data();
211 fragment.payload_.resize(data.size() * 4);
212 std::memcpy(fragment.payload_.data(),
213 reinterpret_cast<const char*
>(data.data()),
216 if (m_verbose_parse_) {
217 ldmx_log(debug) <<
"parsed packing subsystem pkt subsys=" << pkt.id()
218 <<
" data_size=" << data.size();
223 if (m_verbose_parse_)
224 ldmx_log(debug) <<
"failed to parse as either format, skipping frame";
226 m_reader_.
seek(frame_end);
232 m_reader_.
seek(frame_end);
236 if (m_verbose_parse_)
237 ldmx_log(debug) <<
"adding fragment subsys="
238 << fragment.header_.subsystem_id_
239 <<
" ts=" << fragment.header_.timestamp_
240 <<
" bytes=" << fragment.payload_.size();
245 long long fragment_ts = fragment.header_.timestamp_;
246 long long buffer_ref_time = m_event_buffer_.getReferenceTime();
248 if (buffer_ref_time > 0 &&
249 (fragment_ts < buffer_ref_time - m_coherence_window_ns_ ||
254 std::vector<DataFragment> assembled_event_fragments;
255 if (m_event_buffer_.tryBuildEvent(m_coherence_window_ns_,
257 assembled_event_fragments) &&
258 !assembled_event_fragments.empty()) {
262 uint64_t event_timestamp = 0;
263 for (
const auto& frag : assembled_event_fragments) {
265 static_cast<uint8_t
>(frag.header_.subsystem_id_),
266 static_cast<uint8_t
>(frag.header_.contributor_id_));
267 std::vector<uint8_t> payload_bytes(frag.payload_.begin(),
268 frag.payload_.end());
269 event.add(subsys_name, payload_bytes);
270 if (event_timestamp == 0) {
271 event_timestamp = frag.header_.timestamp_;
274 event.getEventHeader().setIntParameter(
275 "RoR Timestamp",
static_cast<long long>(event_timestamp));
276 event.getEventHeader().setRealData();
279 assemblePayload(assembled_event_fragments);
281 ldmx_log(info) <<
"assembled event id=" << m_event_id_
282 <<
" timestamp=" << final_event.timestamp_
283 <<
" fragments=" << assembled_event_fragments.size()
284 <<
" systems=" << final_event.systems_readout_.size();
288 summary.
setTimestampNs(
static_cast<uint64_t
>(final_event.timestamp_));
289 std::set<uint64_t> unique_sys, unique_sources;
290 uint64_t total_payload = 0;
291 for (
const auto& f : assembled_event_fragments) {
292 unique_sys.insert(f.header_.subsystem_id_);
295 unique_sources.insert(f.header_.subsystem_id_ << 8 |
296 f.header_.contributor_id_);
297 total_payload += f.payload_.size();
303 if (unique_sources.size() != assembled_event_fragments.size()) {
306 summary.
setNSystems(
static_cast<uint32_t
>(unique_sys.size()));
308 std::vector<uint64_t>(unique_sys.begin(), unique_sys.end()));
311 event.add(
"EventSummary", summary);
314 m_total_bytes_read_ += total_payload;
315 m_total_events_built_++;
316 m_events_since_last_report_++;
317 std::chrono::steady_clock::time_point now =
318 std::chrono::steady_clock::now();
319 std::chrono::milliseconds event_build_time_ms =
320 std::chrono::duration_cast<std::chrono::milliseconds>(
321 now - m_event_start_time_);
322 std::chrono::seconds total_elapsed_s =
323 std::chrono::duration_cast<std::chrono::seconds>(now -
326 double events_per_sec =
327 (total_elapsed_s.count() > 0)
328 ?
static_cast<double>(m_total_events_built_) /
329 total_elapsed_s.count()
331 double mb_per_sec = (total_elapsed_s.count() > 0)
332 ?
static_cast<double>(m_total_bytes_read_) /
334 total_elapsed_s.count()
338 m_window_events_count_++;
339 m_window_bytes_read_ += total_payload;
340 std::chrono::seconds window_elapsed_s =
341 std::chrono::duration_cast<std::chrono::seconds>(
342 now - m_window_start_time_);
345 double window_events_per_sec = 0.0;
346 double window_mb_per_sec = 0.0;
347 if (m_window_events_count_ >= WINDOW_SIZE) {
348 double window_time_sec =
349 std::max(1.0,
static_cast<double>(window_elapsed_s.count()));
350 window_events_per_sec =
351 static_cast<double>(m_window_events_count_) / window_time_sec;
352 window_mb_per_sec =
static_cast<double>(m_window_bytes_read_) /
353 (1024.0 * 1024.0) / window_time_sec;
356 m_window_start_time_ = now;
357 m_window_events_count_ = 0;
358 m_window_bytes_read_ = 0;
362 long long event_build_time_ms_val = event_build_time_ms.count();
364 static_cast<double>(event_build_time_ms_val),
365 events_per_sec, mb_per_sec,
366 window_events_per_sec, window_mb_per_sec,
367 m_total_events_built_, m_total_bytes_read_);
369 if (m_verbose_parse_ || m_events_since_last_report_ % 100 == 0) {
370 ldmx_log(info) <<
"Performance: "
371 <<
"total_events=" << m_total_events_built_ <<
", "
372 <<
"events_per_sec=" << std::fixed
373 << std::setprecision(2) << events_per_sec <<
", "
374 <<
"mb_per_sec=" << std::fixed << std::setprecision(3)
378 current_event_errors = 0;
384 m_event_buffer_.addFragment(std::move(fragment));
390 m_event_buffer_.addFragment(std::move(fragment));
392 if (m_verbose_parse_)
393 ldmx_log(debug) <<
"frame added to buffer, searching for more frames...";
397 if (m_verbose_parse_)
398 ldmx_log(debug) <<
"reached EOF, flushing remaining events";
400 std::vector<DataFragment> assembled_event_fragments;
401 while (m_event_buffer_.tryBuildEvent(
402 m_coherence_window_ns_, m_min_subsystems_, assembled_event_fragments)) {
403 if (assembled_event_fragments.empty())
break;
410 uint64_t event_timestamp = 0;
411 for (
const auto& frag : assembled_event_fragments) {
413 static_cast<uint8_t
>(frag.header_.subsystem_id_),
414 static_cast<uint8_t
>(frag.header_.contributor_id_));
415 std::vector<uint8_t> payload_bytes(frag.payload_.begin(),
416 frag.payload_.end());
417 event.add(subsys_name, payload_bytes);
418 if (event_timestamp == 0) {
419 event_timestamp = frag.header_.timestamp_;
422 event.getEventHeader().setIntParameter(
423 "RoR Timestamp",
static_cast<long long>(event_timestamp));
424 event.getEventHeader().setRealData();
428 ldmx_log(info) <<
"assembled event id=" << m_event_id_
429 <<
" timestamp=" << final_event.timestamp_
430 <<
" fragments=" << assembled_event_fragments.size()
431 <<
" systems=" << final_event.systems_readout_.size();
435 summary.
setTimestampNs(
static_cast<uint64_t
>(final_event.timestamp_));
436 std::set<uint64_t> unique_sys, unique_sources;
437 uint64_t total_payload = 0;
438 for (
const auto& f : assembled_event_fragments) {
439 unique_sys.insert(f.header_.subsystem_id_);
442 unique_sources.insert(f.header_.subsystem_id_ << 8 |
443 f.header_.contributor_id_);
444 total_payload += f.payload_.size();
450 if (unique_sources.size() != assembled_event_fragments.size()) {
453 summary.
setNSystems(
static_cast<uint32_t
>(unique_sys.size()));
455 std::vector<uint64_t>(unique_sys.begin(), unique_sys.end()));
458 event.add(
"EventSummary", summary);
461 m_total_bytes_read_ += total_payload;
462 m_total_events_built_++;
463 m_events_since_last_report_++;
464 std::chrono::steady_clock::time_point now =
465 std::chrono::steady_clock::now();
466 std::chrono::milliseconds event_build_time_ms =
467 std::chrono::duration_cast<std::chrono::milliseconds>(
468 now - m_event_start_time_);
469 std::chrono::seconds total_elapsed_s =
470 std::chrono::duration_cast<std::chrono::seconds>(now - m_start_time_);
472 double events_per_sec = (total_elapsed_s.count() > 0)
473 ?
static_cast<double>(m_total_events_built_) /
474 total_elapsed_s.count()
476 double mb_per_sec = (total_elapsed_s.count() > 0)
477 ?
static_cast<double>(m_total_bytes_read_) /
478 (1024.0 * 1024.0) / total_elapsed_s.count()
482 m_window_events_count_++;
483 m_window_bytes_read_ += total_payload;
484 std::chrono::seconds window_elapsed_s =
485 std::chrono::duration_cast<std::chrono::seconds>(now -
486 m_window_start_time_);
489 double window_events_per_sec = 0.0;
490 double window_mb_per_sec = 0.0;
491 if (m_window_events_count_ >= WINDOW_SIZE || window_elapsed_s.count() > 0) {
492 double window_time_sec =
493 std::max(1.0,
static_cast<double>(window_elapsed_s.count()));
494 window_events_per_sec =
495 static_cast<double>(m_window_events_count_) / window_time_sec;
496 window_mb_per_sec =
static_cast<double>(m_window_bytes_read_) /
497 (1024.0 * 1024.0) / window_time_sec;
501 long long event_build_time_ms_val = event_build_time_ms.count();
503 static_cast<double>(event_build_time_ms_val),
504 events_per_sec, mb_per_sec, window_events_per_sec,
505 window_mb_per_sec, m_total_events_built_,
506 m_total_bytes_read_);
508 if (m_verbose_parse_ || m_events_since_last_report_ % 100 == 0) {
509 ldmx_log(info) <<
"Performance: "
510 <<
"total_events=" << m_total_events_built_ <<
", "
511 <<
"events_per_sec=" << std::fixed << std::setprecision(2)
512 << events_per_sec <<
", "
513 <<
"mb_per_sec=" << std::fixed << std::setprecision(3)
517 current_event_errors = 0;
519 assembled_event_fragments.clear();
524 std::chrono::steady_clock::time_point final_time =
525 std::chrono::steady_clock::now();
526 std::chrono::seconds total_time_s =
527 std::chrono::duration_cast<std::chrono::seconds>(final_time -
529 double final_events_per_sec =
530 (total_time_s.count() > 0)
531 ?
static_cast<double>(m_total_events_built_) / total_time_s.count()
533 double final_mb_per_sec = (total_time_s.count() > 0)
534 ?
static_cast<double>(m_total_bytes_read_) /
535 (1024.0 * 1024.0) / total_time_s.count()
538 ldmx_log(info) <<
"\n===== FINAL STATISTICS =====";
539 ldmx_log(info) <<
"Total events built: " << m_total_events_built_;
540 ldmx_log(info) <<
"Total bytes read: "
541 << m_total_bytes_read_ / (1024.0 * 1024.0) <<
" MB";
542 ldmx_log(info) <<
"Total time: " << total_time_s.count() <<
" seconds";
543 ldmx_log(info) <<
"Average throughput: "
544 <<
"events_per_sec=" << std::fixed << std::setprecision(2)
545 << final_events_per_sec <<
", "
546 <<
"mb_per_sec=" << std::fixed << std::setprecision(3)
548 ldmx_log(info) <<
"=============================\n";
549 ldmx_log(info) <<
"Event building complete";