artdaq  v3_08_00
SharedMemoryEventManager_t.cc
1 #define TRACE_NAME "SharedMemoryEventManager_t"
2 
3 #include "artdaq-core/Core/SharedMemoryEventReceiver.hh"
4 #include "artdaq-core/Data/Fragment.hh"
5 #include "artdaq/DAQrate/SharedMemoryEventManager.hh"
6 
7 #define BOOST_TEST_MODULE SharedMemoryEventManager_t
8 #include "cetlib/quiet_unit_test.hpp"
9 #include "cetlib_except/exception.h"
10 
11 BOOST_AUTO_TEST_SUITE(SharedMemoryEventManager_test)
12 
13 BOOST_AUTO_TEST_CASE(Construct)
14 {
15  TLOG(TLVL_INFO) << "Test Construct BEGIN";
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.GetSubrunForSequenceID(1), 1);
25  BOOST_REQUIRE_EQUAL(t.GetLockedBufferCount(), 0);
26  TLOG(TLVL_INFO) << "Test Construct END";
27 }
28 
29 BOOST_AUTO_TEST_CASE(AddFragment)
30 {
31  TLOG(TLVL_INFO) << "Test AddFragment BEGIN";
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(TLVL_INFO) << "Test AddFragment END";
52 }
53 
54 BOOST_AUTO_TEST_CASE(DataFlow)
55 {
56  TLOG(TLVL_INFO) << "Test DataFlow BEGIN";
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(TLVL_INFO) << "Test DataFlow END";
97 }
98 
99 BOOST_AUTO_TEST_CASE(TooManyFragments_InterleavedWrites)
100 {
101  TLOG(TLVL_INFO) << "Test TooManyFragments_InterleavedWrites BEGIN";
102  fhicl::ParameterSet pset;
103  pset.put("use_art", false);
104  pset.put("buffer_count", 2);
105  pset.put("max_event_size_bytes", 1000);
106  pset.put("expected_fragments_per_event", 3);
107  pset.put("stale_buffer_timeout_usec", 100000);
108  artdaq::SharedMemoryEventManager t(pset, pset);
109 
110  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
111  frag->resize(4);
112  for (auto ii = 0; ii < 4; ++ii)
113  {
114  *(frag->dataBegin() + ii) = ii;
115  }
116 
117  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
118  auto fragLoc = t.WriteFragmentHeader(hdr);
119  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
120  t.DoneWritingFragment(hdr);
121  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
122  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
123 
124  frag->setFragmentID(1);
125  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
126  auto fragLoc2 = t.WriteFragmentHeader(hdr);
127  frag->setFragmentID(2);
128  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
129  auto fragLoc3 = t.WriteFragmentHeader(hdr);
130  frag->setFragmentID(3);
131  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
132  auto fragLoc4 = t.WriteFragmentHeader(hdr);
133  frag->setFragmentID(4);
134  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
135  auto fragLoc5 = t.WriteFragmentHeader(hdr);
136 
137  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
138  t.DoneWritingFragment(hdr);
139  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
140  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
141 
142  memcpy(fragLoc3, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
143  t.DoneWritingFragment(hdr);
144  BOOST_REQUIRE_EQUAL(fragLoc2 + frag->size(), fragLoc3);
145  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
146  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
147 
148  memcpy(fragLoc4, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
149  t.DoneWritingFragment(hdr);
150  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
151  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
152 
153  memcpy(fragLoc5, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
154  t.DoneWritingFragment(hdr);
155  BOOST_REQUIRE_EQUAL(fragLoc4 + frag->size(), fragLoc5);
156  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
157  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
158 
159  usleep(1000000);
160  {
161  frag->setSequenceID(2);
162  frag->setFragmentID(0);
163 
164  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
165  auto fragLoc = t.WriteFragmentHeader(hdr);
166  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
167  t.DoneWritingFragment(hdr);
168  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
169  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
170  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
171  }
172  TLOG(TLVL_INFO) << "Test TooManyFragments_InterleavedWrites END";
173 }
174 
175 BOOST_AUTO_TEST_CASE(TooManyFragments_DiscreteWrites)
176 {
177  TLOG(TLVL_INFO) << "Test TooManyFragments_DiscreteWrites BEGIN";
178  fhicl::ParameterSet pset;
179  pset.put("use_art", false);
180  pset.put("buffer_count", 2);
181  pset.put("max_event_size_bytes", 1000);
182  pset.put("expected_fragments_per_event", 3);
183  pset.put("stale_buffer_timeout_usec", 100000);
184  artdaq::SharedMemoryEventManager t(pset, pset);
185 
186  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
187  frag->resize(4);
188  for (auto ii = 0; ii < 4; ++ii)
189  {
190  *(frag->dataBegin() + ii) = ii;
191  }
192 
193  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
194  auto fragLoc = t.WriteFragmentHeader(hdr);
195  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
196  t.DoneWritingFragment(hdr);
197  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
198  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
199 
200  frag->setFragmentID(1);
201  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
202  auto fragLoc2 = t.WriteFragmentHeader(hdr);
203 
204  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
205  t.DoneWritingFragment(hdr);
206  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
207  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
208 
209  frag->setFragmentID(2);
210  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
211  auto fragLoc3 = t.WriteFragmentHeader(hdr);
212  memcpy(fragLoc3, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
213  t.DoneWritingFragment(hdr);
214  BOOST_REQUIRE_EQUAL(fragLoc2 + frag->size(), fragLoc3);
215  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
216  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
217 
218  frag->setFragmentID(3);
219  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
220  auto fragLoc4 = t.WriteFragmentHeader(hdr);
221 #if !ART_SUPPORTS_DUPLICATE_EVENTS
222  BOOST_REQUIRE_EQUAL(fragLoc4, t.GetDroppedDataAddress(3));
223 #endif
224  memcpy(fragLoc4, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
225  t.DoneWritingFragment(hdr);
226 #if ART_SUPPORTS_DUPLICATE_EVENTS
227  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
228  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
229 #else
230  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
231  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
232 #endif
233 
234  usleep(1000000);
235  {
236  frag->setSequenceID(2);
237  frag->setFragmentID(0);
238 
239  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
240  auto fragLoc = t.WriteFragmentHeader(hdr);
241  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
242  t.DoneWritingFragment(hdr);
243  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
244  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
245  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
246  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
247  }
248  TLOG(TLVL_INFO) << "Test TooManyFragments_DiscreteWrites END";
249 }
250 
251 /*
252 // Need to check the following scenarios:
253 // 1. Active buffer with lower sequence id than a completed buffer (b. timeout case)
254 // 2a. Inactive buffer with lower sequence id than a completed buffer (b. timeout case)
255 // 2c. Inactive buffer times out and then data arrives (Error case)
256 BOOST_AUTO_TEST_CASE(Ordering_IncompleteActiveBuffer)
257 {
258  TLOG(TLVL_INFO) << "Test Ordering_IncompleteActiveBuffer BEGIN" ;
259  fhicl::ParameterSet pset;
260  pset.put("use_art", false);
261  pset.put("buffer_count", 20);
262  pset.put("max_event_size_bytes", 1000);
263  pset.put("expected_fragments_per_event", 2);
264 
265  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
266  frag->resize(4);
267  for (auto ii = 0; ii < 4; ++ii)
268  {
269  *(frag->dataBegin() + ii) = ii;
270  }
271 
272  artdaq::SharedMemoryEventManager t(pset, pset);
273  {
274 
275  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
276  auto fragLoc = t.WriteFragmentHeader(hdr);
277  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
278  t.DoneWritingFragment(hdr);
279  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
280  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
281  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
282  }
283  {
284  frag->setSequenceID(2);
285  frag->setFragmentID(0);
286 
287  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
288  auto fragLoc = t.WriteFragmentHeader(hdr);
289  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
290  t.DoneWritingFragment(hdr);
291  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
292  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
293  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
294 
295  frag->setFragmentID(1);
296  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
297  auto fragLoc2 = t.WriteFragmentHeader(hdr);
298  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
299  t.DoneWritingFragment(hdr);
300  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
301  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
302  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
303  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
304  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
305 
306  }
307  {
308  frag->setSequenceID(3);
309  frag->setFragmentID(0);
310 
311  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
312  auto fragLoc = t.WriteFragmentHeader(hdr);
313  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
314  t.DoneWritingFragment(hdr);
315  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
316  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
317  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
318 
319  frag->setFragmentID(1);
320  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
321  auto fragLoc2 = t.WriteFragmentHeader(hdr);
322  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
323  t.DoneWritingFragment(hdr);
324  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
325  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
326  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
327  }
328 
329  {
330  frag->setSequenceID(1);
331  frag->setFragmentID(1);
332  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
333  auto fragLoc2 = t.WriteFragmentHeader(hdr);
334  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
335  t.DoneWritingFragment(hdr);
336  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
337  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
338  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
339  }
340  TLOG(TLVL_INFO) << "Test Ordering_IncompleteActiveBuffer END" ;
341 }
342 
343 BOOST_AUTO_TEST_CASE(Ordering_IncompleteActiveBuffer_Timeout)
344 {
345  TLOG(TLVL_INFO) << "Test Ordering_IncompleteActiveBuffer_Timeout BEGIN" ;
346  fhicl::ParameterSet pset;
347  pset.put("use_art", false);
348  pset.put("buffer_count", 20);
349  pset.put("max_event_size_bytes", 1000);
350  pset.put("expected_fragments_per_event", 2);
351  pset.put("stale_buffer_timeout_usec", 100000);
352 
353  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
354  frag->resize(4);
355  for (auto ii = 0; ii < 4; ++ii)
356  {
357  *(frag->dataBegin() + ii) = ii;
358  }
359 
360  artdaq::SharedMemoryEventManager t(pset, pset);
361  {
362  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
363  auto fragLoc = t.WriteFragmentHeader(hdr);
364  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
365  t.DoneWritingFragment(hdr);
366  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
367  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
368  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
369  }
370  {
371  frag->setSequenceID(2);
372  frag->setFragmentID(0);
373 
374  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
375  auto fragLoc = t.WriteFragmentHeader(hdr);
376  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
377  t.DoneWritingFragment(hdr);
378  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
379  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
380  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
381 
382  frag->setFragmentID(1);
383  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
384  auto fragLoc2 = t.WriteFragmentHeader(hdr);
385  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
386  t.DoneWritingFragment(hdr);
387  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
388  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
389  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
390  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
391  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
392 
393  }
394  {
395  frag->setSequenceID(3);
396  frag->setFragmentID(0);
397 
398  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
399  auto fragLoc = t.WriteFragmentHeader(hdr);
400  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
401  t.DoneWritingFragment(hdr);
402  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
403  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
404  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
405 
406  frag->setFragmentID(1);
407  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
408  auto fragLoc2 = t.WriteFragmentHeader(hdr);
409  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
410  t.DoneWritingFragment(hdr);
411  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
412  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
413  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
414  }
415 
416  sleep(1);
417 
418  {
419  frag->setSequenceID(4);
420  frag->setFragmentID(0);
421  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
422  auto fragLoc = t.WriteFragmentHeader(hdr);
423  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
424  t.DoneWritingFragment(hdr);
425  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
426  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
427  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
428 
429  frag->setFragmentID(1);
430  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
431  auto fragLoc2 = t.WriteFragmentHeader(hdr);
432  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
433  t.DoneWritingFragment(hdr);
434  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
435  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
436  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 4);
437  }
438  TLOG(TLVL_INFO) << "Test Ordering_IncompleteActiveBuffer_Timeout END" ;
439 }
440 
441 BOOST_AUTO_TEST_CASE(Ordering_InactiveBuffer)
442 {
443  TLOG(TLVL_INFO) << "Test Ordering_InactiveBuffer BEGIN" ;
444  fhicl::ParameterSet pset;
445  pset.put("use_art", false);
446  pset.put("buffer_count", 20);
447  pset.put("max_event_size_bytes", 1000);
448  pset.put("expected_fragments_per_event", 2);
449 
450  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
451  frag->resize(4);
452  for (auto ii = 0; ii < 4; ++ii)
453  {
454  *(frag->dataBegin() + ii) = ii;
455  }
456 
457  artdaq::SharedMemoryEventManager t(pset, pset);
458  {
459  frag->setSequenceID(2);
460  frag->setFragmentID(0);
461 
462  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
463  auto fragLoc = t.WriteFragmentHeader(hdr);
464  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
465  t.DoneWritingFragment(hdr);
466  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
467  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
468  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
469 
470  frag->setFragmentID(1);
471  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
472  auto fragLoc2 = t.WriteFragmentHeader(hdr);
473  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
474  t.DoneWritingFragment(hdr);
475  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
476  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
477  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
478  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
479  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
480  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
481 
482  }
483  {
484  frag->setSequenceID(3);
485  frag->setFragmentID(0);
486 
487  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
488  auto fragLoc = t.WriteFragmentHeader(hdr);
489  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
490  t.DoneWritingFragment(hdr);
491  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
492  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
493  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
494  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(3), 1);
495  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
496 
497  frag->setFragmentID(1);
498  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
499  auto fragLoc2 = t.WriteFragmentHeader(hdr);
500  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
501  t.DoneWritingFragment(hdr);
502  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
503  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
504  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
505  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
506  }
507 
508  {
509  frag->setSequenceID(1);
510  frag->setFragmentID(0);
511 
512  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
513  auto fragLoc = t.WriteFragmentHeader(hdr);
514  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
515  t.DoneWritingFragment(hdr);
516  frag->setFragmentID(1);
517  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
518  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
519  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
520  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
521 
522  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
523  auto fragLoc2 = t.WriteFragmentHeader(hdr);
524  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
525  t.DoneWritingFragment(hdr);
526  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
527  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
528  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
529  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
530  }
531  TLOG(TLVL_INFO) << "Test Ordering_InactiveBuffer END" ;
532 }
533 
534 BOOST_AUTO_TEST_CASE(Ordering_InactiveBuffer_Timeout)
535 {
536  TLOG(TLVL_INFO) << "Test Ordering_InactiveBuffer_Timeout BEGIN" ;
537  fhicl::ParameterSet pset;
538  pset.put("use_art", false);
539  pset.put("buffer_count", 20);
540  pset.put("max_event_size_bytes", 1000);
541  pset.put("expected_fragments_per_event", 2);
542  pset.put("stale_buffer_timeout_usec", 100000);
543 
544  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
545  frag->resize(4);
546  for (auto ii = 0; ii < 4; ++ii)
547  {
548  *(frag->dataBegin() + ii) = ii;
549  }
550 
551  artdaq::SharedMemoryEventManager t(pset, pset);
552  {
553  frag->setSequenceID(2);
554  frag->setFragmentID(0);
555 
556  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
557  auto fragLoc = t.WriteFragmentHeader(hdr);
558  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
559  t.DoneWritingFragment(hdr);
560  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
561  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
562  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
563 
564  frag->setFragmentID(1);
565  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
566  auto fragLoc2 = t.WriteFragmentHeader(hdr);
567  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
568  t.DoneWritingFragment(hdr);
569  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
570  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
571  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
572  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
573  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
574  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
575 
576  }
577  {
578  frag->setSequenceID(3);
579  frag->setFragmentID(0);
580 
581  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
582  auto fragLoc = t.WriteFragmentHeader(hdr);
583  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
584  t.DoneWritingFragment(hdr);
585  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
586  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
587  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
588  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(3), 1);
589  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
590 
591  frag->setFragmentID(1);
592  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
593  auto fragLoc2 = t.WriteFragmentHeader(hdr);
594  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
595  t.DoneWritingFragment(hdr);
596  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
597  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
598  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
599  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
600  }
601 
602  sleep(1);
603 
604  {
605  frag->setSequenceID(4);
606  frag->setFragmentID(1);
607  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
608  auto fragLoc2 = t.WriteFragmentHeader(hdr);
609  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
610  t.DoneWritingFragment(hdr);
611  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
612  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
613  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
614  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 2);
615  }
616  TLOG(TLVL_INFO) << "Test Ordering_InactiveBuffer_Timeout END" ;
617 }
618 */
619 //SharedMemoryEventManager should print error messages, but consume data for buffers which have timed out
620 BOOST_AUTO_TEST_CASE(ConsumeDroppedData_Active)
621 {
622  TLOG(TLVL_INFO) << "Test ConsumeDroppedData_Active BEGIN";
623  fhicl::ParameterSet pset;
624  pset.put("use_art", false);
625  pset.put("buffer_count", 20);
626  pset.put("max_event_size_bytes", 1000);
627  pset.put("expected_fragments_per_event", 2);
628  pset.put("stale_buffer_timeout_usec", 100000);
629 
630  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
631  frag->resize(4);
632  for (auto ii = 0; ii < 4; ++ii)
633  {
634  *(frag->dataBegin() + ii) = ii;
635  }
636 
637  artdaq::SharedMemoryEventManager t(pset, pset);
638  {
639  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
640  auto fragLoc = t.WriteFragmentHeader(hdr);
641  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
642  t.DoneWritingFragment(hdr);
643  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
644  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
645  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(1), 1);
646  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
647  }
648  {
649  frag->setSequenceID(2);
650  frag->setFragmentID(0);
651 
652  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
653  auto fragLoc = t.WriteFragmentHeader(hdr);
654  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
655  t.DoneWritingFragment(hdr);
656  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
657  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
658  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
659  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
660 
661  frag->setFragmentID(1);
662  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
663  auto fragLoc2 = t.WriteFragmentHeader(hdr);
664  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
665  t.DoneWritingFragment(hdr);
666  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
667  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
668  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
669  //BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
670  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
671  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
672  }
673  {
674  frag->setSequenceID(3);
675  frag->setFragmentID(0);
676 
677  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
678  auto fragLoc = t.WriteFragmentHeader(hdr);
679  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
680  t.DoneWritingFragment(hdr);
681  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 2);
682  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
683  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(3), 1);
684  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 1);
685 
686  frag->setFragmentID(1);
687  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
688  auto fragLoc2 = t.WriteFragmentHeader(hdr);
689  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
690  t.DoneWritingFragment(hdr);
691  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
692  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
693  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
694  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 2);
695  }
696 
697  sleep(1);
698 
699  {
700  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 2);
701  frag->setSequenceID(4);
702  frag->setFragmentID(1);
703  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
704  auto fragLoc = t.WriteFragmentHeader(hdr);
705  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
706  t.DoneWritingFragment(hdr);
707  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
708  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
709  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
710  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
711 
712  frag->setFragmentID(1);
713  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
714  auto fragLoc2 = t.WriteFragmentHeader(hdr);
715  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
716  t.DoneWritingFragment(hdr);
717  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
718  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
719  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 4);
720  }
721  {
722  frag->setSequenceID(1);
723  frag->setFragmentID(1);
724  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
725  auto fragLoc2 = t.WriteFragmentHeader(hdr);
726 #if !ART_SUPPORTS_DUPLICATE_EVENTS
727  BOOST_REQUIRE_EQUAL(fragLoc2, t.GetDroppedDataAddress(1));
728 #endif
729  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
730  t.DoneWritingFragment(hdr);
731  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
732  //BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
733  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
734 #if ART_SUPPORTS_DUPLICATE_EVENTS
735  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 5);
736 #else
737  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 4);
738 #endif
739  }
740 
741  TLOG(TLVL_INFO) << "Test ConsumeDroppedData_Active END";
742 }
743 /*
744 //SharedMemoryEventManager should print error messages, but consume data for buffers which have timed out
745 BOOST_AUTO_TEST_CASE(ConsumeDroppedData_Inactive)
746 {
747  TLOG(TLVL_INFO) << "Test ConsumeDroppedData_Inactive BEGIN" ;
748  fhicl::ParameterSet pset;
749  pset.put("use_art", false);
750  pset.put("buffer_count", 20);
751  pset.put("max_event_size_bytes", 1000);
752  pset.put("expected_fragments_per_event", 2);
753  pset.put("stale_buffer_timeout_usec", 100000);
754 
755  artdaq::FragmentPtr frag(new artdaq::Fragment(1, 0, artdaq::Fragment::FirstUserFragmentType, 0UL)), tmpFrag;
756  frag->resize(4);
757  for (auto ii = 0; ii < 4; ++ii)
758  {
759  *(frag->dataBegin() + ii) = ii;
760  }
761 
762  artdaq::SharedMemoryEventManager t(pset, pset);
763  {
764  frag->setSequenceID(2);
765  frag->setFragmentID(0);
766 
767  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
768  auto fragLoc = t.WriteFragmentHeader(hdr);
769  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
770  t.DoneWritingFragment(hdr);
771  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
772  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
773  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 1);
774  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
775 
776  frag->setFragmentID(1);
777  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
778  auto fragLoc2 = t.WriteFragmentHeader(hdr);
779  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
780  t.DoneWritingFragment(hdr);
781  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 1);
782  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
783  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
784  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(2), 2);
785  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
786  BOOST_REQUIRE_EQUAL(fragLoc + frag->size(), fragLoc2);
787 
788  }
789  {
790  frag->setSequenceID(3);
791  frag->setFragmentID(0);
792 
793  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
794  auto fragLoc = t.WriteFragmentHeader(hdr);
795  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
796  t.DoneWritingFragment(hdr);
797  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
798  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
799  BOOST_REQUIRE_EQUAL(t.GetFragmentCount(3), 1);
800  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(),1);
801  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
802 
803  frag->setFragmentID(1);
804  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
805  auto fragLoc2 = t.WriteFragmentHeader(hdr);
806  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
807  t.DoneWritingFragment(hdr);
808  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 2);
809  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 1);
810  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
811  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
812  }
813 
814  sleep(1);
815 
816  {
817  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 0);
818  frag->setSequenceID(4);
819  frag->setFragmentID(1);
820  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
821  auto fragLoc = t.WriteFragmentHeader(hdr);
822  memcpy(fragLoc, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
823  t.DoneWritingFragment(hdr);
824  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
825  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
826  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 1);
827  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 2);
828 
829  frag->setFragmentID(1);
830  hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
831  auto fragLoc2 = t.WriteFragmentHeader(hdr);
832  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
833  t.DoneWritingFragment(hdr);
834  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
835  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
836  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
837  }
838  {
839  frag->setSequenceID(1);
840  frag->setFragmentID(1);
841  auto hdr = *reinterpret_cast<artdaq::detail::RawFragmentHeader*>(frag->headerAddress());
842  auto fragLoc2 = t.WriteFragmentHeader(hdr);
843  BOOST_REQUIRE_EQUAL(fragLoc2, t.GetDroppedDataAddress(1));
844  memcpy(fragLoc2, frag->dataBegin(), 4 * sizeof(artdaq::RawDataType));
845  t.DoneWritingFragment(hdr);
846  BOOST_REQUIRE_EQUAL(t.GetPendingEventCount(), 0);
847  BOOST_REQUIRE_EQUAL(t.GetInactiveEventCount(), 0);
848  BOOST_REQUIRE_EQUAL(t.GetIncompleteEventCount(), 0);
849  BOOST_REQUIRE_EQUAL(t.GetArtEventCount(), 3);
850  }
851  TLOG(TLVL_INFO) << "Test ConsumeDroppedData_Inactive END" ;
852 }
853 */
854 
855 BOOST_AUTO_TEST_CASE(RunNumbers)
856 {
857  TLOG(TLVL_INFO) << "Test RunNumbers BEGIN";
858  fhicl::ParameterSet pset;
859  pset.put("use_art", false);
860  pset.put("buffer_count", 2);
861  pset.put("max_event_size_bytes", 1000);
862  pset.put("expected_fragments_per_event", 2);
863  artdaq::SharedMemoryEventManager t(pset, pset);
864 
865  t.startRun(1);
866  BOOST_REQUIRE_EQUAL(t.runID(), 1);
867  BOOST_REQUIRE_EQUAL(t.GetCurrentSubrun(), 1);
868  t.rolloverSubrun();
869  BOOST_REQUIRE_EQUAL(t.runID(), 1);
870  BOOST_REQUIRE_EQUAL(t.GetCurrentSubrun(), 2);
871  t.rolloverSubrun();
872  BOOST_REQUIRE_EQUAL(t.runID(), 1);
873  BOOST_REQUIRE_EQUAL(t.GetCurrentSubrun(), 3);
874  t.startRun(3);
875  BOOST_REQUIRE_EQUAL(t.runID(), 3);
876  BOOST_REQUIRE_EQUAL(t.GetCurrentSubrun(), 1);
877 
878  artdaq::SharedMemoryEventReceiver r(t.GetKey(), t.GetBroadcastKey());
879  bool errflag = false;
880 
881  t.endRun();
882  bool sts = r.ReadyForRead();
883  BOOST_REQUIRE_EQUAL(sts, true);
884  auto hdr = r.ReadHeader(errflag);
885  BOOST_REQUIRE_EQUAL(errflag, false);
886  BOOST_REQUIRE(hdr != nullptr);
887  if (hdr != nullptr)
888  { // Make static analyzer happy
889  BOOST_REQUIRE_EQUAL(hdr->is_complete, true);
890  BOOST_REQUIRE_EQUAL(hdr->run_id, 3);
891  BOOST_REQUIRE_EQUAL(hdr->subrun_id, 1);
892  }
893  auto frags = r.GetFragmentsByType(errflag, artdaq::Fragment::EndOfRunFragmentType);
894  BOOST_REQUIRE_EQUAL(errflag, false);
895  BOOST_REQUIRE_EQUAL(frags->size(), 1);
896  r.ReleaseBuffer();
897 
898  TLOG(TLVL_INFO) << "Test RunNumbers END";
899 }
900 
901 BOOST_AUTO_TEST_SUITE_END()
The SharedMemoryEventManager is a SharedMemoryManger which tracks events as they are built...