artdaq  v3_00_03
SharedMemoryEventManager_t.cc
1 
2 #include "artdaq/DAQrate/SharedMemoryEventManager.hh"
3 #include "artdaq-core/Data/Fragment.hh"
4 #include "artdaq-core/Core/SharedMemoryEventReceiver.hh"
5 
6 #define BOOST_TEST_MODULE SharedMemoryEventManager_t
7 #include "cetlib/quiet_unit_test.hpp"
8 #include "cetlib_except/exception.h"
9 
10 
11 BOOST_AUTO_TEST_SUITE(SharedMemoryEventManager_test)
12 
13 BOOST_AUTO_TEST_CASE(Construct)
14 {
15  TLOG_INFO("SharedMemoryEventManager_t") << "Test Construct BEGIN" << TLOG_ENDL;
16  fhicl::ParameterSet pset;
17  pset.put("use_art", false);
18  pset.put("buffer_count", 2);
19  pset.put("max_event_size_bytes", 1000);
20  pset.put("expected_fragments_per_event", 2);
22 
23  BOOST_REQUIRE_EQUAL(t.runID(), 0);
24  BOOST_REQUIRE_EQUAL(t.subrunID(), 0);
25  BOOST_REQUIRE_EQUAL(t.GetLockedBufferCount(), 0);
26  TLOG_INFO("SharedMemoryEventManager_t") << "Test Construct END" << TLOG_ENDL;
27 }
28 
29 BOOST_AUTO_TEST_CASE(AddFragment)
30 {
31  TLOG_INFO("SharedMemoryEventManager_t") << "Test AddFragment BEGIN" << TLOG_ENDL;
32 
33  fhicl::ParameterSet pset;
34  pset.put("use_art", false);
35  pset.put("buffer_count", 2);
36  pset.put("max_event_size_bytes", 1000);
37  pset.put("expected_fragments_per_event", 2);
39 
40  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
41  frag->resize(4);
42  for (auto ii = 0; ii < 4; ++ii)
43  {
44  *(frag->dataBegin() + ii) = ii;
45  }
46 
47  bool sts = t.AddFragment(std::move(frag), 1000000, tmpFrag);
48  BOOST_REQUIRE_EQUAL(sts, true);
49  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
50  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
51  TLOG_INFO("SharedMemoryEventManager_t") << "Test AddFragment END" << TLOG_ENDL;
52 }
53 
54 BOOST_AUTO_TEST_CASE(DataFlow)
55 {
56  TLOG_INFO("SharedMemoryEventManager_t") << "Test DataFlow BEGIN" << TLOG_ENDL;
57  fhicl::ParameterSet pset;
58  pset.put("use_art", false);
59  pset.put("buffer_count", 2);
60  pset.put("max_event_size_bytes", 1000);
61  pset.put("expected_fragments_per_event", 3);
63 
64  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
65  frag->resize(4);
66  for (auto ii = 0; ii < 4; ++ii)
67  {
68  *(frag->dataBegin() + ii) = ii;
69  }
70 
71  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
72  auto fragLoc = t.WriteFragmentHeader(hdr);
73  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
74  t.DoneWritingFragment(hdr);
75  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
76  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
77 
78  frag->setFragmentID(1);
79  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
80  auto fragLoc2 = t.WriteFragmentHeader(hdr);
81  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
82  t.DoneWritingFragment(hdr);
83  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
84  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 2);
85  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
86 
87  frag->setFragmentID(2);
88  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
89  auto fragLoc3 = t.WriteFragmentHeader(hdr);
90  memcpy(fragLoc3, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
91  t.DoneWritingFragment(hdr);
92  BOOST_REQUIRE_EQUAL(fragLoc2 + frag->size(), fragLoc3);
93  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
94  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
95 
96  TLOG_INFO("SharedMemoryEventManager_t") << "Test DataFlow END" << TLOG_ENDL;
97 }
98 
99 /*
100 // Need to check the following scenarios:
101 // 1. Active buffer with lower sequence id than a completed buffer (b. timeout case)
102 // 2a. Inactive buffer with lower sequence id than a completed buffer (b. timeout case)
103 // 2c. Inactive buffer times out and then data arrives (Error case)
104 BOOST_AUTO_TEST_CASE(Ordering_IncompleteActiveBuffer)
105 {
106  TLOG_INFO("SharedMemoryEventManager_t") << "Test Ordering_IncompleteActiveBuffer BEGIN" << TLOG_ENDL;
107  fhicl::ParameterSet pset;
108  pset.put("use_art", false);
109  pset.put("buffer_count", 20);
110  pset.put("max_event_size_bytes", 1000);
111  pset.put("expected_fragments_per_event", 2);
112 
113  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
114  frag->resize(4);
115  for (auto ii = 0; ii < 4; ++ii)
116  {
117  *(frag->dataBegin() + ii) = ii;
118  }
119 
120  artdaq::SharedMemoryEventManager t(pset, pset);
121  {
122 
123  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
124  auto fragLoc = t.WriteFragmentHeader(hdr);
125  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
126  t.DoneWritingFragment(hdr);
127  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
128  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
129  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
130  }
131  {
132  frag->setSequenceID(2);
133  frag->setFragmentID(0);
134 
135  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
136  auto fragLoc = t.WriteFragmentHeader(hdr);
137  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
138  t.DoneWritingFragment(hdr);
139  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
140  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
141  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
142 
143  frag->setFragmentID(1);
144  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
145  auto fragLoc2 = t.WriteFragmentHeader(hdr);
146  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
147  t.DoneWritingFragment(hdr);
148  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
149  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
150  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
151  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
152  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
153 
154  }
155  {
156  frag->setSequenceID(3);
157  frag->setFragmentID(0);
158 
159  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
160  auto fragLoc = t.WriteFragmentHeader(hdr);
161  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
162  t.DoneWritingFragment(hdr);
163  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
164  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
165  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
166 
167  frag->setFragmentID(1);
168  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
169  auto fragLoc2 = t.WriteFragmentHeader(hdr);
170  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
171  t.DoneWritingFragment(hdr);
172  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
173  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
174  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
175  }
176 
177  {
178  frag->setSequenceID(1);
179  frag->setFragmentID(1);
180  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
181  auto fragLoc2 = t.WriteFragmentHeader(hdr);
182  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
183  t.DoneWritingFragment(hdr);
184  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
185  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
186  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
187  }
188  TLOG_INFO("SharedMemoryEventManager_t") << "Test Ordering_IncompleteActiveBuffer END" << TLOG_ENDL;
189 }
190 
191 BOOST_AUTO_TEST_CASE(Ordering_IncompleteActiveBuffer_Timeout)
192 {
193  TLOG_INFO("SharedMemoryEventManager_t") << "Test Ordering_IncompleteActiveBuffer_Timeout BEGIN" << TLOG_ENDL;
194  fhicl::ParameterSet pset;
195  pset.put("use_art", false);
196  pset.put("buffer_count", 20);
197  pset.put("max_event_size_bytes", 1000);
198  pset.put("expected_fragments_per_event", 2);
199  pset.put("stale_buffer_timeout_usec", 100000);
200 
201  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
202  frag->resize(4);
203  for (auto ii = 0; ii < 4; ++ii)
204  {
205  *(frag->dataBegin() + ii) = ii;
206  }
207 
208  artdaq::SharedMemoryEventManager t(pset, pset);
209  {
210  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
211  auto fragLoc = t.WriteFragmentHeader(hdr);
212  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
213  t.DoneWritingFragment(hdr);
214  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
215  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
216  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
217  }
218  {
219  frag->setSequenceID(2);
220  frag->setFragmentID(0);
221 
222  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
223  auto fragLoc = t.WriteFragmentHeader(hdr);
224  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
225  t.DoneWritingFragment(hdr);
226  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
227  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
228  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
229 
230  frag->setFragmentID(1);
231  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
232  auto fragLoc2 = t.WriteFragmentHeader(hdr);
233  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
234  t.DoneWritingFragment(hdr);
235  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
236  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
237  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
238  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
239  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
240 
241  }
242  {
243  frag->setSequenceID(3);
244  frag->setFragmentID(0);
245 
246  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
247  auto fragLoc = t.WriteFragmentHeader(hdr);
248  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
249  t.DoneWritingFragment(hdr);
250  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
251  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
252  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
253 
254  frag->setFragmentID(1);
255  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
256  auto fragLoc2 = t.WriteFragmentHeader(hdr);
257  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
258  t.DoneWritingFragment(hdr);
259  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
260  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
261  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
262  }
263 
264  sleep(1);
265 
266  {
267  frag->setSequenceID(4);
268  frag->setFragmentID(0);
269  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
270  auto fragLoc = t.WriteFragmentHeader(hdr);
271  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
272  t.DoneWritingFragment(hdr);
273  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
274  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
275  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
276 
277  frag->setFragmentID(1);
278  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
279  auto fragLoc2 = t.WriteFragmentHeader(hdr);
280  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
281  t.DoneWritingFragment(hdr);
282  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
283  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
284  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 4);
285  }
286  TLOG_INFO("SharedMemoryEventManager_t") << "Test Ordering_IncompleteActiveBuffer_Timeout END" << TLOG_ENDL;
287 }
288 
289 BOOST_AUTO_TEST_CASE(Ordering_InactiveBuffer)
290 {
291  TLOG_INFO("SharedMemoryEventManager_t") << "Test Ordering_InactiveBuffer BEGIN" << TLOG_ENDL;
292  fhicl::ParameterSet pset;
293  pset.put("use_art", false);
294  pset.put("buffer_count", 20);
295  pset.put("max_event_size_bytes", 1000);
296  pset.put("expected_fragments_per_event", 2);
297 
298  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
299  frag->resize(4);
300  for (auto ii = 0; ii < 4; ++ii)
301  {
302  *(frag->dataBegin() + ii) = ii;
303  }
304 
305  artdaq::SharedMemoryEventManager t(pset, pset);
306  {
307  frag->setSequenceID(2);
308  frag->setFragmentID(0);
309 
310  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
311  auto fragLoc = t.WriteFragmentHeader(hdr);
312  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
313  t.DoneWritingFragment(hdr);
314  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
315  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
316  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
317 
318  frag->setFragmentID(1);
319  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
320  auto fragLoc2 = t.WriteFragmentHeader(hdr);
321  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
322  t.DoneWritingFragment(hdr);
323  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
324  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
325  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
326  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
327  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
328  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
329 
330  }
331  {
332  frag->setSequenceID(3);
333  frag->setFragmentID(0);
334 
335  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
336  auto fragLoc = t.WriteFragmentHeader(hdr);
337  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
338  t.DoneWritingFragment(hdr);
339  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
340  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
341  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
342  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(3), 1);
343  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
344 
345  frag->setFragmentID(1);
346  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
347  auto fragLoc2 = t.WriteFragmentHeader(hdr);
348  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
349  t.DoneWritingFragment(hdr);
350  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
351  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
352  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
353  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
354  }
355 
356  {
357  frag->setSequenceID(1);
358  frag->setFragmentID(0);
359 
360  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
361  auto fragLoc = t.WriteFragmentHeader(hdr);
362  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
363  t.DoneWritingFragment(hdr);
364  frag->setFragmentID(1);
365  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
366  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
367  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
368  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
369 
370  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
371  auto fragLoc2 = t.WriteFragmentHeader(hdr);
372  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
373  t.DoneWritingFragment(hdr);
374  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
375  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
376  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
377  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
378  }
379  TLOG_INFO("SharedMemoryEventManager_t") << "Test Ordering_InactiveBuffer END" << TLOG_ENDL;
380 }
381 
382 BOOST_AUTO_TEST_CASE(Ordering_InactiveBuffer_Timeout)
383 {
384  TLOG_INFO("SharedMemoryEventManager_t") << "Test Ordering_InactiveBuffer_Timeout BEGIN" << TLOG_ENDL;
385  fhicl::ParameterSet pset;
386  pset.put("use_art", false);
387  pset.put("buffer_count", 20);
388  pset.put("max_event_size_bytes", 1000);
389  pset.put("expected_fragments_per_event", 2);
390  pset.put("stale_buffer_timeout_usec", 100000);
391 
392  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
393  frag->resize(4);
394  for (auto ii = 0; ii < 4; ++ii)
395  {
396  *(frag->dataBegin() + ii) = ii;
397  }
398 
399  artdaq::SharedMemoryEventManager t(pset, pset);
400  {
401  frag->setSequenceID(2);
402  frag->setFragmentID(0);
403 
404  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
405  auto fragLoc = t.WriteFragmentHeader(hdr);
406  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
407  t.DoneWritingFragment(hdr);
408  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
409  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
410  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
411 
412  frag->setFragmentID(1);
413  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
414  auto fragLoc2 = t.WriteFragmentHeader(hdr);
415  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
416  t.DoneWritingFragment(hdr);
417  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
418  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
419  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
420  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
421  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
422  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
423 
424  }
425  {
426  frag->setSequenceID(3);
427  frag->setFragmentID(0);
428 
429  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
430  auto fragLoc = t.WriteFragmentHeader(hdr);
431  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
432  t.DoneWritingFragment(hdr);
433  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
434  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
435  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
436  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(3), 1);
437  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
438 
439  frag->setFragmentID(1);
440  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
441  auto fragLoc2 = t.WriteFragmentHeader(hdr);
442  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
443  t.DoneWritingFragment(hdr);
444  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
445  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
446  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
447  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
448  }
449 
450  sleep(1);
451 
452  {
453  frag->setSequenceID(4);
454  frag->setFragmentID(1);
455  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
456  auto fragLoc2 = t.WriteFragmentHeader(hdr);
457  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
458  t.DoneWritingFragment(hdr);
459  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
460  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
461  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
462  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 2);
463  }
464  TLOG_INFO("SharedMemoryEventManager_t") << "Test Ordering_InactiveBuffer_Timeout END" << TLOG_ENDL;
465 }
466 */
467 //SharedMemoryEventManager should print error messages, but consume data for buffers which have timed out
468 BOOST_AUTO_TEST_CASE(ConsumeDroppedData_Active)
469 {
470  TLOG_INFO("SharedMemoryEventManager_t") << "Test ConsumeDroppedData_Active BEGIN" << TLOG_ENDL;
471  fhicl::ParameterSet pset;
472  pset.put("use_art", false);
473  pset.put("buffer_count", 20);
474  pset.put("max_event_size_bytes", 1000);
475  pset.put("expected_fragments_per_event", 2);
476  pset.put("stale_buffer_timeout_usec", 100000);
477 
478  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
479  frag->resize(4);
480  for (auto ii = 0; ii < 4; ++ii)
481  {
482  *(frag->dataBegin() + ii) = ii;
483  }
484 
485  artdaq::SharedMemoryEventManager t(pset, pset);
486  {
487 
488  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
489  auto fragLoc = t.WriteFragmentHeader(hdr);
490  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
491  t.DoneWritingFragment(hdr);
492  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
493  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
494  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
495  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
496  }
497  {
498  frag->setSequenceID(2);
499  frag->setFragmentID(0);
500 
501  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
502  auto fragLoc = t.WriteFragmentHeader(hdr);
503  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
504  t.DoneWritingFragment(hdr);
505  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
506  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
507  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
508  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
509 
510  frag->setFragmentID(1);
511  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
512  auto fragLoc2 = t.WriteFragmentHeader(hdr);
513  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
514  t.DoneWritingFragment(hdr);
515  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
516  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
517  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
518  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
519  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
520  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
521 
522  }
523  {
524  frag->setSequenceID(3);
525  frag->setFragmentID(0);
526 
527  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
528  auto fragLoc = t.WriteFragmentHeader(hdr);
529  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
530  t.DoneWritingFragment(hdr);
531  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
532  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
533  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(3), 1);
534  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
535 
536  frag->setFragmentID(1);
537  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
538  auto fragLoc2 = t.WriteFragmentHeader(hdr);
539  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
540  t.DoneWritingFragment(hdr);
541  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
542  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
543  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
544  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
545  }
546 
547  sleep(1);
548 
549  {
550  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
551  frag->setSequenceID(4);
552  frag->setFragmentID(1);
553  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
554  auto fragLoc = t.WriteFragmentHeader(hdr);
555  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
556  t.DoneWritingFragment(hdr);
557  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
558  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
559  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
560  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
561 
562  frag->setFragmentID(1);
563  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
564  auto fragLoc2 = t.WriteFragmentHeader(hdr);
565  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
566  t.DoneWritingFragment(hdr);
567  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
568  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
569  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 4);
570  }
571  {
572  frag->setSequenceID(1);
573  frag->setFragmentID(1);
574  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
575  auto fragLoc2 = t.WriteFragmentHeader(hdr);
576 #if !ART_SUPPORTS_DUPLICATE_EVENTS
577  BOOST_REQUIRE_EQUAL(fragLoc2, t.GetDroppedDataAddress());
578 #endif
579  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
580  t.DoneWritingFragment(hdr);
581  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
582  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
583  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
584 #if ART_SUPPORTS_DUPLICATE_EVENTS
585  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 5);
586 #else
587  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 4);
588 #endif
589  }
590 
591  TLOG_INFO("SharedMemoryEventManager_t") << "Test ConsumeDroppedData_Active END" << TLOG_ENDL;
592 }
593 /*
594 //SharedMemoryEventManager should print error messages, but consume data for buffers which have timed out
595 BOOST_AUTO_TEST_CASE(ConsumeDroppedData_Inactive)
596 {
597  TLOG_INFO("SharedMemoryEventManager_t") << "Test ConsumeDroppedData_Inactive BEGIN" << TLOG_ENDL;
598  fhicl::ParameterSet pset;
599  pset.put("use_art", false);
600  pset.put("buffer_count", 20);
601  pset.put("max_event_size_bytes", 1000);
602  pset.put("expected_fragments_per_event", 2);
603  pset.put("stale_buffer_timeout_usec", 100000);
604 
605  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
606  frag->resize(4);
607  for (auto ii = 0; ii < 4; ++ii)
608  {
609  *(frag->dataBegin() + ii) = ii;
610  }
611 
612  artdaq::SharedMemoryEventManager t(pset, pset);
613  {
614  frag->setSequenceID(2);
615  frag->setFragmentID(0);
616 
617  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
618  auto fragLoc = t.WriteFragmentHeader(hdr);
619  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
620  t.DoneWritingFragment(hdr);
621  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
622  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
623  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
624  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
625 
626  frag->setFragmentID(1);
627  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
628  auto fragLoc2 = t.WriteFragmentHeader(hdr);
629  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
630  t.DoneWritingFragment(hdr);
631  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
632  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
633  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
634  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
635  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
636  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
637 
638  }
639  {
640  frag->setSequenceID(3);
641  frag->setFragmentID(0);
642 
643  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
644  auto fragLoc = t.WriteFragmentHeader(hdr);
645  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
646  t.DoneWritingFragment(hdr);
647  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
648  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
649  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(3), 1);
650  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(),1);
651  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
652 
653  frag->setFragmentID(1);
654  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
655  auto fragLoc2 = t.WriteFragmentHeader(hdr);
656  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
657  t.DoneWritingFragment(hdr);
658  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
659  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
660  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
661  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
662  }
663 
664  sleep(1);
665 
666  {
667  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
668  frag->setSequenceID(4);
669  frag->setFragmentID(1);
670  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
671  auto fragLoc = t.WriteFragmentHeader(hdr);
672  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
673  t.DoneWritingFragment(hdr);
674  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
675  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
676  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
677  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 2);
678 
679  frag->setFragmentID(1);
680  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
681  auto fragLoc2 = t.WriteFragmentHeader(hdr);
682  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
683  t.DoneWritingFragment(hdr);
684  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
685  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
686  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
687  }
688  {
689  frag->setSequenceID(1);
690  frag->setFragmentID(1);
691  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
692  auto fragLoc2 = t.WriteFragmentHeader(hdr);
693  BOOST_REQUIRE_EQUAL(fragLoc2, t.GetDroppedDataAddress());
694  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
695  t.DoneWritingFragment(hdr);
696  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
697  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
698  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
699  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
700  }
701  TLOG_INFO("SharedMemoryEventManager_t") << "Test ConsumeDroppedData_Inactive END" << TLOG_ENDL;
702 }
703 */
704 
705 BOOST_AUTO_TEST_CASE(RunNumbers)
706 {
707  TLOG_INFO("SharedMemoryEventManager_t") << "Test RunNumbers BEGIN" << TLOG_ENDL;
708  fhicl::ParameterSet pset;
709  pset.put("use_art", false);
710  pset.put("buffer_count", 2);
711  pset.put("max_event_size_bytes", 1000);
712  pset.put("expected_fragments_per_event", 2);
713  artdaq::SharedMemoryEventManager t(pset, pset);
714 
715  t.startRun(1);
716  BOOST_REQUIRE_EQUAL(t.runID(), 1);
717  BOOST_REQUIRE_EQUAL(t.subrunID(), 1);
718  t.startSubrun();
719  BOOST_REQUIRE_EQUAL(t.runID(), 1);
720  BOOST_REQUIRE_EQUAL(t.subrunID(), 2);
721  t.startSubrun();
722  BOOST_REQUIRE_EQUAL(t.runID(), 1);
723  BOOST_REQUIRE_EQUAL(t.subrunID(), 3);
724  t.startRun(3);
725  BOOST_REQUIRE_EQUAL(t.runID(), 3);
726  BOOST_REQUIRE_EQUAL(t.subrunID(), 1);
727 
728 
729  artdaq::SharedMemoryEventReceiver r(t.GetKey(), t.GetBroadcastKey());
730  t.endSubrun();
731  bool errflag = false;
732  bool sts = r.ReadyForRead();
733  BOOST_REQUIRE_EQUAL(sts, true);
734  auto hdr = r.ReadHeader(errflag);
735  BOOST_REQUIRE_EQUAL(errflag, false);
736  BOOST_REQUIRE(hdr != nullptr);
737  BOOST_REQUIRE_EQUAL(hdr->is_complete, true);
738  BOOST_REQUIRE_EQUAL(hdr->run_id, 3);
739  BOOST_REQUIRE_EQUAL(hdr->subrun_id, 1);
740  auto frags = r.GetFragmentsByType(errflag, artdaq::Fragment::EndOfSubrunFragmentType);
741  BOOST_REQUIRE_EQUAL(errflag, false);
742  BOOST_REQUIRE_EQUAL(frags->size(), 1);
743  r.ReleaseBuffer();
744 
745  t.endRun();
746  sts = r.ReadyForRead();
747  BOOST_REQUIRE_EQUAL(sts, true);
748  hdr = r.ReadHeader(errflag);
749  BOOST_REQUIRE_EQUAL(errflag, false);
750  BOOST_REQUIRE(hdr != nullptr);
751  BOOST_REQUIRE_EQUAL(hdr->is_complete, true);
752  BOOST_REQUIRE_EQUAL(hdr->run_id, 3);
753  BOOST_REQUIRE_EQUAL(hdr->subrun_id, 1);
754  frags = r.GetFragmentsByType(errflag, artdaq::Fragment::EndOfRunFragmentType);
755  BOOST_REQUIRE_EQUAL(errflag, false);
756  BOOST_REQUIRE_EQUAL(frags->size(), 1);
757  r.ReleaseBuffer();
758 
759  TLOG_INFO("SharedMemoryEventManager_t") << "Test RunNumbers END" << TLOG_ENDL;
760 }
761 
762 BOOST_AUTO_TEST_SUITE_END()
The SharedMemoryEventManager is a SharedMemoryManger which tracks events as they are built...