Process the event and put new data products into it.
118 {
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;
125 }
126
127
128 m_event_start_time_ = std::chrono::steady_clock::now();
129
130
131 uint32_t current_event_errors = 0;
132
133 while (m_reader_ && !m_reader_.
eof()) {
134
136 frame_header.
read(m_reader_);
137
138
139 const long long frame_end =
140 static_cast<long long>(m_reader_.
tell()) + frame_header.
size();
141
142
144
145 if (m_verbose_parse_)
146 ldmx_log(debug) << "skipping non-data frame (channel="
147 << frame_header.
channel() <<
")";
148 m_reader_.
seek(frame_end);
149 continue;
150 }
151
152
154 bool parsed_ok = false;
155
156
158 int pos_before_ror = m_reader_.
tell();
159
160
161 try {
162 ror_header.
read(m_reader_);
163 if (!ror_header.
valid())
throw std::runtime_error(
"invalid RoR header");
164
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();
171
172 if (m_verbose_parse_) {
173 ldmx_log(debug) << "parsed RoR header subsys="
177 }
178
179
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()),
185 payload_size);
186 }
187 fragment.payload_ = std::move(payload_data);
188 parsed_ok = true;
189 } catch (...) {
190
191 if (m_verbose_parse_)
192 ldmx_log(debug)
193 << "RoR header parse failed, trying packing subsystem format";
195 m_reader_.
seek(pos_before_ror);
196 }
197
198 if (!parsed_ok) {
199
201 try {
203 fragment.header_.subsystem_id_ = static_cast<uint64_t>(pkt.id());
204 fragment.header_.contributor_id_ =
205 0;
206 fragment.header_.timestamp_ =
static_cast<uint64_t
>(pkt.
header()[1]) *
207 1000000000ULL;
208
209
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()),
214 data.size() * 4);
215
216 if (m_verbose_parse_) {
217 ldmx_log(debug) << "parsed packing subsystem pkt subsys=" << pkt.id()
218 << " data_size=" << data.size();
219 }
220 parsed_ok = true;
221 } catch (...) {
222
223 if (m_verbose_parse_)
224 ldmx_log(debug) << "failed to parse as either format, skipping frame";
226 m_reader_.
seek(frame_end);
227 continue;
228 }
229 }
230
231 if (!parsed_ok) {
232 m_reader_.
seek(frame_end);
233 continue;
234 }
235
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();
241
242
243
244
245 long long fragment_ts = fragment.header_.timestamp_;
246 long long buffer_ref_time = m_event_buffer_.getReferenceTime();
247
248 if (buffer_ref_time > 0 &&
249 (fragment_ts < buffer_ref_time - m_coherence_window_ns_ ||
250 fragment_ts >
252
253
254 std::vector<DataFragment> assembled_event_fragments;
255 if (m_event_buffer_.tryBuildEvent(m_coherence_window_ns_,
256 m_min_subsystems_,
257 assembled_event_fragments) &&
258 !assembled_event_fragments.empty()) {
259
260 ++m_event_id_;
261
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_;
272 }
273 }
274 event.getEventHeader().setIntParameter(
275 "RoR Timestamp", static_cast<long long>(event_timestamp));
276 event.getEventHeader().setRealData();
277
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();
285
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_);
293
294
295 unique_sources.insert(f.header_.subsystem_id_ << 8 |
296 f.header_.contributor_id_);
297 total_payload += f.payload_.size();
300 }
301 }
302
303 if (unique_sources.size() != assembled_event_fragments.size()) {
305 }
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);
312
313
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 -
324 m_start_time_);
325
326 double events_per_sec =
327 (total_elapsed_s.count() > 0)
328 ? static_cast<double>(m_total_events_built_) /
329 total_elapsed_s.count()
330 : 0.0;
331 double mb_per_sec = (total_elapsed_s.count() > 0)
332 ? static_cast<double>(m_total_bytes_read_) /
333 (1024.0 * 1024.0) /
334 total_elapsed_s.count()
335 : 0.0;
336
337
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_);
343
344
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;
354
355
356 m_window_start_time_ = now;
357 m_window_events_count_ = 0;
358 m_window_bytes_read_ = 0;
359 }
360
361
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_);
368
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)
375 << mb_per_sec;
376 }
377
378 current_event_errors = 0;
379
380
381
382
383
384 m_event_buffer_.addFragment(std::move(fragment));
385 return;
386 }
387 }
388
389
390 m_event_buffer_.addFragment(std::move(fragment));
391
392 if (m_verbose_parse_)
393 ldmx_log(debug) << "frame added to buffer, searching for more frames...";
394 }
395
396
397 if (m_verbose_parse_)
398 ldmx_log(debug) << "reached EOF, flushing remaining events";
399
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;
404
405
407
408 ++m_event_id_;
409
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_;
420 }
421 }
422 event.getEventHeader().setIntParameter(
423 "RoR Timestamp", static_cast<long long>(event_timestamp));
424 event.getEventHeader().setRealData();
425
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();
432
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_);
440
441
442 unique_sources.insert(f.header_.subsystem_id_ << 8 |
443 f.header_.contributor_id_);
444 total_payload += f.payload_.size();
447 }
448 }
449
450 if (unique_sources.size() != assembled_event_fragments.size()) {
452 }
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);
459
460
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_);
471
472 double events_per_sec = (total_elapsed_s.count() > 0)
473 ? static_cast<double>(m_total_events_built_) /
474 total_elapsed_s.count()
475 : 0.0;
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()
479 : 0.0;
480
481
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_);
487
488
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;
498 }
499
500
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_);
507
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)
514 << mb_per_sec;
515 }
516
517 current_event_errors = 0;
518
519 assembled_event_fragments.clear();
520 return;
521 }
522
523
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 -
528 m_start_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()
532 : 0.0;
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()
536 : 0.0;
537
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)
547 << final_mb_per_sec;
548 ldmx_log(info) << "=============================\n";
549 ldmx_log(info) << "Event building complete";
550
552}
void abortEvent()
Abort the event immediately.
Provides summary information about an assembled event, including error flags for data quality assessm...
void setSystemIds(const std::vector< uint64_t > &ids)
Set the system IDs.
void setNSystems(uint32_t ns)
Set the number of systems in this event.
void setPayloadSize(uint64_t size)
Set the total payload size.
void setTimestampNs(uint64_t ts)
Set the timestamp in nanoseconds.
void setEventNumber(uint64_t num)
Set the event number.
void setErrorFlags(uint32_t flags)
Set the error flags.
@ ERROR_PARSE_FAILURE
Frame parsing error.
@ ERROR_DATA_DROPPED
A fragment is header only, its data dropped (DAQ busy)
@ ERROR_DUPLICATE_SUBSYSTEM
Duplicate subsystem in single event.
@ ERROR_TRUNCATED_EVENT
Event was truncated (EOF reached)
SubsystemPacket structure.
std::vector< uint32_t > & data()
Get data.
utility::Reader & read(utility::Reader &r)
read the subsystem packet from the input reader
std::vector< uint32_t > header() const
get the header words
std::streampos tell()
Tell us where the reader is.
bool eof()
check if file is done
void seek(std::streampos off, std::ios_base::seekdir dir=std::ios::beg)
Go ("seek") a specific position in the file.
Reader & read(WordType *w, std::size_t count)
Read the next 'count' words into the input handle.