| The Gaudi Framework v30r0 (c919700c)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

HiveSlimEventLoopMgr.cpp
Go to the documentation of this file.
1 // FW includes
2 #include "GaudiKernel/AppReturnCode.h"
3 #include "GaudiKernel/DataObject.h"
4 #include "GaudiKernel/DataSvc.h"
5 #include "GaudiKernel/IAlgManager.h"
6 #include "GaudiKernel/IChronoStatSvc.h"
7 #include "GaudiKernel/IConversionSvc.h"
8 #include "GaudiKernel/IDataManagerSvc.h"
9 #include "GaudiKernel/IDataProviderSvc.h"
10 #include "GaudiKernel/IEvtSelector.h"
11 #include "GaudiKernel/IIncidentListener.h"
12 #include "GaudiKernel/IIncidentSvc.h"
13 #include "GaudiKernel/Incident.h"
14 #include "GaudiKernel/MsgStream.h"
15 #include "GaudiKernel/SmartIF.h"
16 #include "GaudiKernel/SvcFactory.h"
17
18 #include "HistogramAgent.h"
19
20 #include "GaudiHive/HiveSlimEventLoopMgr.h"
21
22 #include "GaudiKernel/Algorithm.h"
23 #include "GaudiKernel/EventContext.h"
24
25 #include <GaudiKernel/GaudiException.h>
26
27 #include <GaudiKernel/IScheduler.h>
28
29 // External libraries
30 #include <chrono>
31
32 // Instantiation of a static factory class used by clients to create instances of this service
33 DECLARE_SERVICE_FACTORY( HiveSlimEventLoopMgr )
34
35 #define ON_DEBUG if ( UNLIKELY( outputLevel() <= MSG::DEBUG ) )
36 #define ON_VERBOSE if ( UNLIKELY( outputLevel() <= MSG::VERBOSE ) )
37
38 #define DEBMSG ON_DEBUG debug()
39 #define VERMSG ON_VERBOSE verbose()
40
41 //--------------------------------------------------------------------------------------------
42 // Standard Constructor
43 //--------------------------------------------------------------------------------------------
44 HiveSlimEventLoopMgr::HiveSlimEventLoopMgr( const std::string& name, ISvcLocator* svcLoc )
45 : base_class( name, svcLoc ), m_appMgrUI( svcLoc )
46 {
47 }
48
49 //--------------------------------------------------------------------------------------------
50 // Standard Destructor
51 //--------------------------------------------------------------------------------------------
52 HiveSlimEventLoopMgr::~HiveSlimEventLoopMgr()
53 {
54 m_histoDataMgrSvc.reset();
55 m_histoPersSvc.reset();
56 m_evtDataMgrSvc.reset();
57 m_whiteboard.reset();
58 m_evtSelector.reset();
59 if ( m_evtContext ) delete m_evtContext;
60 }
61
62 //--------------------------------------------------------------------------------------------
63 // implementation of IAppMgrUI::initialize
64 //--------------------------------------------------------------------------------------------
65 StatusCode HiveSlimEventLoopMgr::initialize()
66 {
67
68 if ( !m_appMgrUI.isValid() ) {
69 return StatusCode::FAILURE;
70 }
71
72 StatusCode sc = Service::initialize();
73 if ( !sc.isSuccess() ) {
74 error() << "Failed to initialize Service Base class." << endmsg;
75 return StatusCode::FAILURE;
76 }
77
78 // Get the references to the services that are needed by the ApplicationMgr itself
79 m_incidentSvc = serviceLocator()->service( "IncidentSvc" );
80 if ( !m_incidentSvc.isValid() ) {
81 fatal() << "Error retrieving IncidentSvc." << endmsg;
82 return StatusCode::FAILURE;
83 }
84
85 // Setup access to event data services
86 m_evtDataMgrSvc = serviceLocator()->service( "EventDataSvc" );
87 if ( !m_evtDataMgrSvc.isValid() ) {
88 fatal() << "Error retrieving EventDataSvc interface IDataManagerSvc." << endmsg;
89 return StatusCode::FAILURE;
90 }
91 m_whiteboard = serviceLocator()->service( "EventDataSvc" );
92 if ( !m_whiteboard.isValid() ) {
93 fatal() << "Error retrieving EventDataSvc interface IHiveWhiteBoard." << endmsg;
94 return StatusCode::FAILURE;
95 }
96 m_schedulerSvc = serviceLocator()->service( m_schedulerName );
97 if ( !m_schedulerSvc.isValid() ) {
98 fatal() << "Error retrieving SchedulerSvc interface IScheduler." << endmsg;
99 return StatusCode::FAILURE;
100 }
101 // Obtain the IProperty of the ApplicationMgr
102 m_appMgrProperty = serviceLocator();
103 if ( !m_appMgrProperty.isValid() ) {
104 fatal() << "IProperty interface not found in ApplicationMgr." << endmsg;
105 return StatusCode::FAILURE;
106 }
107
108 // We do not expect a Event Selector necessarily being declared
109 setProperty( m_appMgrProperty->getProperty( "EvtSel" ) ).ignore();
110
111 if ( m_evtsel != "NONE" || m_evtsel.length() == 0 ) {
112 m_evtSelector = serviceLocator()->service( "EventSelector" );
113 if ( m_evtSelector.isValid() ) {
114 // Setup Event Selector
115 sc = m_evtSelector->createContext( m_evtContext );
116 if ( !sc.isSuccess() ) {
117 fatal() << "Can not create the event selector Context." << endmsg;
118 return sc;
119 }
120 } else {
121 fatal() << "EventSelector not found." << endmsg;
122 return sc;
123 }
124 } else {
125 m_evtSelector = 0;
126 m_evtContext = 0;
127 if ( m_warnings ) {
128 warning() << "Unable to locate service \"EventSelector\" " << endmsg;
129 warning() << "No events will be processed from external input." << endmsg;
130 }
131 }
132
133 // Setup access to histogramming services
134 m_histoDataMgrSvc = serviceLocator()->service( "HistogramDataSvc" );
135 if ( !m_histoDataMgrSvc.isValid() ) {
136 fatal() << "Error retrieving HistogramDataSvc." << endmsg;
137 return sc;
138 }
139 // Setup histogram persistency
140 m_histoPersSvc = serviceLocator()->service( "HistogramPersistencySvc" );
141 if ( !m_histoPersSvc.isValid() ) {
142 warning() << "Histograms cannot not be saved - though required." << endmsg;
143 return sc;
144 }
145
146 // Setup algorithm resource pool
147 m_algResourcePool = serviceLocator()->service( "AlgResourcePool" );
148 if ( !m_algResourcePool.isValid() ) {
149 fatal() << "Error retrieving AlgResourcePool" << endmsg;
150 return StatusCode::FAILURE;
151 }
152
153 m_algExecStateSvc = serviceLocator()->service( "AlgExecStateSvc" );
154 if ( !m_algExecStateSvc.isValid() ) {
155 fatal() << "Error retrieving AlgExecStateSvc" << endmsg;
156 return StatusCode::FAILURE;
157 }
158
159 std::sort( m_eventNumberBlacklist.begin(), m_eventNumberBlacklist.end() );
160 info() << "Found " << m_eventNumberBlacklist.size() << " events in black list" << endmsg;
161
162 return StatusCode::SUCCESS;
163 }
164 //--------------------------------------------------------------------------------------------
165 // implementation of IService::reinitialize
166 //--------------------------------------------------------------------------------------------
167 StatusCode HiveSlimEventLoopMgr::reinitialize()
168 {
169
170 // Check to see whether a new Event Selector has been specified
171 setProperty( m_appMgrProperty->getProperty( "EvtSel" ) );
172 if ( m_evtsel != "NONE" || m_evtsel.length() == 0 ) {
173 SmartIF<IService> theSvc( serviceLocator()->service( "EventSelector" ) );
174 SmartIF<IEvtSelector> theEvtSel( theSvc );
175 StatusCode sc;
176 if ( theEvtSel.isValid() && ( theEvtSel.get() != m_evtSelector.get() ) ) {
177 // Setup Event Selector
178 if ( m_evtSelector.get() && m_evtContext ) {
179 // Need to release context before switching to new event selector
180 m_evtSelector->releaseContext( m_evtContext );
181 m_evtContext = 0;
182 }
183 m_evtSelector = theEvtSel;
184 if ( theSvc->FSMState() == Gaudi::StateMachine::INITIALIZED ) {
185 sc = theSvc->reinitialize();
186 if ( !sc.isSuccess() ) {
187 error() << "Failure Reinitializing EventSelector " << theSvc->name() << endmsg;
188 return sc;
189 }
190 } else {
191 sc = theSvc->sysInitialize();
192 if ( !sc.isSuccess() ) {
193 error() << "Failure Initializing EventSelector " << theSvc->name() << endmsg;
194 return sc;
195 }
196 }
197 sc = m_evtSelector->createContext( m_evtContext );
198 if ( !sc.isSuccess() ) {
199 error() << "Can not create Context " << theSvc->name() << endmsg;
200 return sc;
201 }
202
203 } else if ( m_evtSelector.isValid() ) {
204 if ( m_evtContext ) {
205 m_evtSelector->releaseContext( m_evtContext );
206 m_evtContext = 0;
207 }
208 sc = m_evtSelector->createContext( m_evtContext );
209 if ( !sc.isSuccess() ) {
210 error() << "Can not create Context " << theSvc->name() << endmsg;
211 return sc;
212 }
213 }
214 } else if ( m_evtSelector.isValid() && m_evtContext ) {
215 m_evtSelector->releaseContext( m_evtContext );
216 m_evtSelector = 0;
217 m_evtContext = 0;
218 }
219 return StatusCode::SUCCESS;
220 }
221
222 //--------------------------------------------------------------------------------------------
223 // implementation of IService::stop
224 //--------------------------------------------------------------------------------------------
225 // Removed call to MinimalEventLoopMgr!
226 StatusCode HiveSlimEventLoopMgr::stop()
227 {
228 if ( !m_endEventFired ) {
229 // Fire pending EndEvent incident
230 m_incidentSvc->fireIncident( Incident( name(), IncidentType::EndEvent ) );
231 m_endEventFired = true;
232 }
233 return StatusCode::SUCCESS;
234 }
235
236 //--------------------------------------------------------------------------------------------
237 // implementation of IAppMgrUI::finalize
238 //--------------------------------------------------------------------------------------------
239 // Removed call to MinimalEventLoopMgr!
240 StatusCode HiveSlimEventLoopMgr::finalize()
241 {
242
243 StatusCode scRet;
244 StatusCode sc = Service::finalize();
245
246 if ( sc.isFailure() ) {
247 scRet = StatusCode::FAILURE;
248 error() << "Problems finalizing Service base class" << endmsg;
249 }
250
251 // Save Histograms Now
252 if ( m_histoPersSvc != 0 ) {
253 HistogramAgent agent;
254 sc = m_histoDataMgrSvc->traverseTree( &agent );
255 if ( sc.isSuccess() ) {
256 IDataSelector* objects = agent.selectedObjects();
257 // skip /stat entry!
258 if ( objects->size() > 0 ) {
259 IDataSelector::iterator i;
260 for ( i = objects->begin(); i != objects->end(); i++ ) {
261 IOpaqueAddress* pAddr = 0;
262 StatusCode iret = m_histoPersSvc->createRep( *i, pAddr );
263 if ( iret.isSuccess() ) {
264 ( *i )->registry()->setAddress( pAddr );
265 } else {
266 sc = iret;
267 }
268 }
269 for ( i = objects->begin(); i != objects->end(); i++ ) {
270 IRegistry* reg = ( *i )->registry();
271 StatusCode iret = m_histoPersSvc->fillRepRefs( reg->address(), *i );
272 if ( !iret.isSuccess() ) {
273 sc = iret;
274 }
275 }
276 }
277 if ( sc.isSuccess() ) {
278 info() << "Histograms converted successfully according to request." << endmsg;
279 } else {
280 error() << "Error while saving Histograms." << endmsg;
281 }
282 } else {
283 error() << "Error while traversing Histogram data store" << endmsg;
284 }
285 }
286
287 scRet = sc;
288
289 // Release event selector context
290 if ( m_evtSelector && m_evtContext ) {
291 m_evtSelector->releaseContext( m_evtContext ).ignore();
292 m_evtContext = 0;
293 }
294
295 m_incidentSvc = 0; // release
296 m_appMgrUI = 0; // release
297
298 // Release all interfaces...
299 m_histoDataMgrSvc = 0;
300 m_histoPersSvc = 0;
301
302 m_evtSelector = 0;
303 m_whiteboard = 0;
304 m_evtDataMgrSvc = 0;
305
306 return scRet;
307 }
308
309 //--------------------------------------------------------------------------------------------
310 // implementation of executeEvent(void* par)
311 //--------------------------------------------------------------------------------------------
312 StatusCode HiveSlimEventLoopMgr::executeEvent( void* createdEvts_IntPtr )
313 {
314
315 // Leave the interface intact and swallow this C trick.
316 int& createdEvts = *( (int*)createdEvts_IntPtr );
317
318 EventContext* evtContext( nullptr );
319
320 // Check if event number is in blacklist
321 if ( LIKELY( m_blackListBS != nullptr ) ) { // we are processing a finite number of events, use bitset blacklist
322 if ( m_blackListBS->test( createdEvts ) ) {
323 verbose() << "Event " << createdEvts << " on black list" << endmsg;
324 return StatusCode::RECOVERABLE;
325 }
326 } else if ( std::binary_search( m_eventNumberBlacklist.begin(), m_eventNumberBlacklist.end(), createdEvts ) ) {
327
328 verbose() << "Event " << createdEvts << " on black list" << endmsg;
329 return StatusCode::RECOVERABLE;
330 }
331
332 if ( createEventContext( evtContext, createdEvts ).isFailure() ) {
333 fatal() << "Impossible to create event context" << endmsg;
334 return StatusCode::FAILURE;
335 }
336
337 verbose() << "Beginning to process event " << createdEvts << endmsg;
338
339 // An incident may schedule a stop, in which case is better to exit before the actual execution.
340 // DP have to find out who shoots this
341 /* if ( m_scheduledStop ) {
342 always() << "Terminating event processing loop due to a stop scheduled by an incident listener" << endmsg;
343 return StatusCode::SUCCESS;
344 }*/
345
346 StatusCode declEvtRootSc = declareEventRootAddress();
347 if ( declEvtRootSc.isFailure() ) { // We ran out of events!
348 createdEvts = -1; // Set created event to a negative value: we finished!
349 return StatusCode::SUCCESS;
350 }
351
352 // Fire BeginEvent "Incident"
353 m_incidentSvc->fireIncident(
354 std::unique_ptr<Incident>( new Incident( name(), IncidentType::BeginEvent, *evtContext ) ) );
355
356 // Now add event to the scheduler
357 verbose() << "Adding event " << evtContext->evt() << ", slot " << evtContext->slot() << " to the scheduler" << endmsg;
358
359 m_incidentSvc->fireIncident(
360 std::unique_ptr<Incident>( new Incident( name(), IncidentType::BeginProcessing, *evtContext ) ) );
361
362 StatusCode addEventStatus = m_schedulerSvc->pushNewEvent( evtContext );
363
364 // If this fails, we need to wait for something to complete
365 if ( !addEventStatus.isSuccess() ) {
366 fatal() << "An event processing slot should be now free in the scheduler, but it appears not to be the case."
367 << endmsg;
368 }
369
370 createdEvts++;
371 return StatusCode::SUCCESS;
372 }
373
374 //--------------------------------------------------------------------------------------------
375 // implementation of IEventProcessing::executeRun
376 //--------------------------------------------------------------------------------------------
377 StatusCode HiveSlimEventLoopMgr::executeRun( int maxevt )
378 {
379 StatusCode sc;
380 bool eventfailed = false;
381
382 if ( maxevt > 0 ) { // finite number of events to process
383 const unsigned int umaxevt = static_cast<unsigned int>( maxevt );
384 m_blackListBS = new boost::dynamic_bitset<>( maxevt ); // all initialized to zero
385 for ( unsigned int i = 0; i < m_eventNumberBlacklist.size() && m_eventNumberBlacklist[i] <= umaxevt;
386 ++i ) { // black list is sorted in init
387 m_blackListBS->set( m_eventNumberBlacklist[i], true );
388 }
389 }
390
391 sc = m_algResourcePool->beginRun();
392 if ( sc.isFailure() ) eventfailed = true;
393
394 // Call now the nextEvent(...)
395 sc = nextEvent( maxevt );
396 if ( !sc.isSuccess() ) eventfailed = true;
397
398 sc = m_algResourcePool->endRun();
399 if ( sc.isFailure() ) eventfailed = true;
400
401 if ( m_blackListBS != nullptr ) delete m_blackListBS;
402
403 if ( eventfailed )
404 return StatusCode::FAILURE;
405 else
406 return StatusCode::SUCCESS;
407 }
408
409 //--------------------------------------------------------------------------------------------
410 // Implementation of IEventProcessor::stopRun()
411 //--------------------------------------------------------------------------------------------
412 StatusCode HiveSlimEventLoopMgr::stopRun()
413 {
414 // Set the application return code
415 SmartIF<IProperty> appmgr( serviceLocator() );
416 if ( Gaudi::setAppReturnCode( appmgr, Gaudi::ReturnCode::ScheduledStop ).isFailure() ) {
417 error() << "Could not set return code of the application (" << Gaudi::ReturnCode::ScheduledStop << ")" << endmsg;
418 }
419 m_scheduledStop = true;
420 return StatusCode::SUCCESS;
421 }
422
423 //--------------------------------------------------------------------------------------------
424 // implementation of IAppMgrUI::nextEvent
425 //--------------------------------------------------------------------------------------------
426 // Here the loop on the events takes place.
427 // This is also the natural place to put the preparation of the algorithms
428 // contexts, which contain the event specific data.
429 #include "GaudiKernel/Memory.h"
430 StatusCode HiveSlimEventLoopMgr::nextEvent( int maxevt )
431 {
432
433 // Calculate runtime
434 typedef std::chrono::high_resolution_clock Clock;
435 typedef Clock::time_point time_point;
436
437 // Reset the application return code.
438 Gaudi::setAppReturnCode( m_appMgrProperty, Gaudi::ReturnCode::Success, true ).ignore();
439
440 int finishedEvts = 0;
441 int createdEvts = 0;
442 int skippedEvts = 0;
443 info() << "Starting loop on events" << endmsg;
444 // Loop until the finished events did not reach the maxevt number
445 bool loop_ended = false;
446 // Run the first event before spilling more than one
447 bool newEvtAllowed = false;
448
449 constexpr double oneOver1204 = 1. / 1024.;
450
451 uint iteration = 0;
452 time_point start_time = Clock::now();
453 while ( !loop_ended and ( maxevt < 0 or ( finishedEvts + skippedEvts ) < maxevt ) ) {
454 debug() << "work loop iteration " << iteration++ << endmsg;
455 // if the created events did not reach maxevt, create an event
456 if ( ( newEvtAllowed or createdEvts == 0 ) && // Launch the first event alone
457 createdEvts >= 0 && // The events are not finished with an unlimited number of events
458 ( createdEvts < maxevt or maxevt < 0 ) && // The events are not finished with a limited number of events
459 m_schedulerSvc->freeSlots() > 0 && // There are still free slots in the scheduler
460 m_whiteboard->freeSlots() > 0 ) { // There are still free slots in the whiteboard
461
462 if ( 1 == createdEvts ) // reset counter to count from event 1
463 start_time = Clock::now();
464
465 debug() << "createdEvts: " << createdEvts << ", freeslots: " << m_schedulerSvc->freeSlots() << endmsg;
466 // DP remove to remove the syscalls...
467 // if (0!=createdEvts){
468 // info() << "Event Number = " << createdEvts
469 // << " WSS (MB) = " << System::mappedMemory(System::MemoryUnit::kByte)*oneOver1204
470 // << " Time (s) = " << secsFromStart(start_time) << endmsg;
471 // }
472
473 // TODO can we adapt the interface of executeEvent for a nicer solution?
474 StatusCode sc = StatusCode::RECOVERABLE;
475 while ( !sc.isSuccess() // we haven't created an event yet
476 && ( createdEvts < maxevt or maxevt < 0 ) ) { // redunant check for maxEvts, can we do better?
477 sc = executeEvent( &createdEvts );
478
479 if ( sc.isRecoverable() ) { // we skipped an event
480
481 // this is all to skip the event
482 size_t slot =
483 m_whiteboard->allocateStore( createdEvts ); // we need a new store, not to change the previous event
484 m_whiteboard->selectStore( slot );
485 declareEventRootAddress(); // actually skip over the event
486 m_whiteboard->freeStore( slot ); // delete the store
487
488 ++createdEvts;
489 ++skippedEvts;
490 } else if ( sc.isRecoverable() ) { // exit immediatly
491 return StatusCode::FAILURE;
492 } // else we have an success --> exit loop
493 }
494
495 } // end if condition createdEvts < maxevt
496 else {
497 // all the events were created but not all finished or the slots were
498 // all busy: the scheduler should finish its job
499
500 debug() << "Draining the scheduler" << endmsg;
501
502 // Pull out of the scheduler the finished events
503 if ( drainScheduler( finishedEvts ).isFailure() ) {
504 loop_ended = true;
505 }
506 newEvtAllowed = true;
507 }
508 } // end main loop on finished events
509 time_point end_time = Clock::now();
510
511 info() << "---> Loop Finished (skipping 1st evt) - "
512 << " WSS " << System::mappedMemory( System::MemoryUnit::kByte ) * oneOver1204 << " total time "
513 << std::chrono::duration_cast<std::chrono::nanoseconds>( end_time - start_time ).count() << endmsg;
514 info() << skippedEvts << " events were SKIPed" << endmsg;
515
516 return StatusCode::SUCCESS;
517 }
518
519 //---------------------------------------------------------------------------
520
522 StatusCode HiveSlimEventLoopMgr::getEventRoot( IOpaqueAddress*& refpAddr )
523 {
524 refpAddr = 0;
525 StatusCode sc = m_evtSelector->next( *m_evtContext );
526 if ( !sc.isSuccess() ) {
527 return sc;
528 }
529 // Create root address and assign address to data service
530 sc = m_evtSelector->createAddress( *m_evtContext, refpAddr );
531 if ( !sc.isSuccess() ) {
532 sc = m_evtSelector->next( *m_evtContext );
533 if ( sc.isSuccess() ) {
534 sc = m_evtSelector->createAddress( *m_evtContext, refpAddr );
535 if ( !sc.isSuccess() ) {
536 warning() << "Error creating IOpaqueAddress." << endmsg;
537 }
538 }
539 }
540 return sc;
541 }
542
543 //---------------------------------------------------------------------------
544
545 StatusCode HiveSlimEventLoopMgr::declareEventRootAddress()
546 {
547
548 StatusCode sc;
549 if ( m_evtContext ) {
550 //---This is the "event iterator" context from EventSelector
551 IOpaqueAddress* pAddr = 0;
552 sc = getEventRoot( pAddr );
553 if ( !sc.isSuccess() ) {
554 info() << "No more events in event selection " << endmsg;
555 return StatusCode::FAILURE;
556 }
557 sc = m_evtDataMgrSvc->setRoot( "/Event", pAddr );
558 if ( !sc.isSuccess() ) {
559 warning() << "Error declaring event root address." << endmsg;
560 }
561 } else {
562 //---In case of no event selector----------------
563 sc = m_evtDataMgrSvc->setRoot( "/Event", new DataObject() );
564 if ( !sc.isSuccess() ) {
565 warning() << "Error declaring event root DataObject" << endmsg;
566 }
567 }
568 return StatusCode::SUCCESS;
569 }
570
571 //---------------------------------------------------------------------------
572
573 StatusCode HiveSlimEventLoopMgr::createEventContext( EventContext*& evtContext, int createdEvts )
574 {
575 evtContext = new EventContext;
576
577 evtContext->set( createdEvts, m_whiteboard->allocateStore( createdEvts ) );
578
579 m_algExecStateSvc->reset( *evtContext );
580
581 StatusCode sc = m_whiteboard->selectStore( evtContext->slot() );
582 if ( sc.isFailure() ) {
583 warning() << "Slot " << evtContext->slot() << " could not be selected for the WhiteBoard" << endmsg;
584 }
585 return sc;
586 }
587
588 //---------------------------------------------------------------------------
589
590 StatusCode HiveSlimEventLoopMgr::drainScheduler( int& finishedEvts )
591 {
592
593 StatusCode sc( StatusCode::SUCCESS );
594
595 // maybe we can do better
596 std::vector<EventContext*> finishedEvtContexts;
597
598 EventContext* finishedEvtContext( nullptr );
599
600 // Here we wait not to loose cpu resources
601 debug() << "Waiting for a context" << endmsg;
602 sc = m_schedulerSvc->popFinishedEvent( finishedEvtContext );
603
604 // We got past it: cache the pointer
605 if ( sc.isSuccess() ) {
606 debug() << "Context obtained" << endmsg;
607 } else {
608 // A problem occurred.
609 debug() << "Context not obtained: a problem in the scheduling?" << endmsg;
610 // return StatusCode::FAILURE;
611 }
612
613 finishedEvtContexts.push_back( finishedEvtContext );
614
615 // Let's see if we can pop other event contexts
616 while ( m_schedulerSvc->tryPopFinishedEvent( finishedEvtContext ).isSuccess() ) {
617 finishedEvtContexts.push_back( finishedEvtContext );
618 }
619
620 // Now we flush them
621 StatusCode finalSC;
622 for ( auto& thisFinishedEvtContext : finishedEvtContexts ) {
623 if ( nullptr == thisFinishedEvtContext ) {
624 error() << "Detected nullptr ctxt before clearing WB!" << endmsg;
625 finalSC = StatusCode::FAILURE;
626 continue;
627 }
628 if ( m_algExecStateSvc->eventStatus( *thisFinishedEvtContext ) != EventStatus::Success ) {
629 fatal() << "Failed event detected on " << thisFinishedEvtContext << endmsg;
630 finalSC = StatusCode::FAILURE;
631 }
632 // shouldn't these incidents move to the forward scheduler?
633 // If we want to consume incidents with an algorithm at the end of the graph
634 // we need to add this to forward scheduler lambda action,
635 // otherwise we have to do this serially on this thread!
636 m_incidentSvc->fireIncident( Incident( name(), IncidentType::EndProcessing, *thisFinishedEvtContext ) );
637 m_incidentSvc->fireIncident( Incident( name(), IncidentType::EndEvent, *thisFinishedEvtContext ) );
638
639 debug() << "Clearing slot " << thisFinishedEvtContext->slot() << " (event " << thisFinishedEvtContext->evt()
640 << ") of the whiteboard" << endmsg;
641
642 StatusCode sc = clearWBSlot( thisFinishedEvtContext->slot() );
643 if ( !sc.isSuccess() )
644 error() << "Whiteboard slot " << thisFinishedEvtContext->slot() << " could not be properly cleared";
645
646 delete thisFinishedEvtContext;
647
648 finishedEvts++;
649 }
650 return finalSC;
651 }
652
653 //---------------------------------------------------------------------------
654
655 StatusCode HiveSlimEventLoopMgr::clearWBSlot( int evtSlot )
656 {
657 StatusCode sc = m_whiteboard->clearStore( evtSlot );
658 if ( !sc.isSuccess() ) {
659 warning() << "Clear of Event data store failed" << endmsg;
660 }
661 return m_whiteboard->freeStore( evtSlot );
662 }
663 //---------------------------------------------------------------------------
IDataManagerSvc::traverseTree
virtual StatusCode traverseTree(IDataStoreAgent *pAgent)=0
Analyse by traversing all data objects in the data store.
HiveSlimEventLoopMgr::clearWBSlot
StatusCode clearWBSlot(int evtSlot)
Clear a slot in the WB.
Definition: HiveSlimEventLoopMgr.cpp:655
StatusCode::SUCCESS
Definition: StatusCode.h:29
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:64
std::chrono::nanoseconds
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:17
HiveSlimEventLoopMgr::m_evtsel
Gaudi::Property< std::string > m_evtsel
Definition: HiveSlimEventLoopMgr.h:31
HiveSlimEventLoopMgr::m_incidentSvc
SmartIF< IIncidentSvc > m_incidentSvc
Reference to the incident service.
Definition: HiveSlimEventLoopMgr.h:75
Algorithm.h
SmartIF< IService >
HiveSlimEventLoopMgr::m_evtDataMgrSvc
SmartIF< IDataManagerSvc > m_evtDataMgrSvc
Reference to the Event Data Service&#39;s IDataManagerSvc interface.
Definition: HiveSlimEventLoopMgr.h:38
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
HiveSlimEventLoopMgr::declareEventRootAddress
StatusCode declareEventRootAddress()
Declare the root address of the event.
Definition: HiveSlimEventLoopMgr.cpp:545
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:289
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:32
EventContext::set
void set(const ContextEvt_t &e=0, const ContextID_t &s=INVALID_CONTEXT_ID)
Definition: EventContext.h:44
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:174
PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >::setProperty
StatusCode setProperty(const Gaudi::Details::PropertyBase &p) override
set the property form another property
Definition: PropertyHolder.h:208
EventContext::slot
ContextID_t slot() const
Definition: EventContext.h:40
MsgStream.h
HiveSlimEventLoopMgr::m_appMgrUI
SmartIF< IAppMgrUI > m_appMgrUI
Reference to the IAppMgrUI interface of the application manager.
Definition: HiveSlimEventLoopMgr.h:73
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:112
HiveSlimEventLoopMgr::HiveSlimEventLoopMgr
HiveSlimEventLoopMgr(const std::string &nam, ISvcLocator *svcLoc)
Standard Constructor.
Definition: HiveSlimEventLoopMgr.cpp:44
HiveSlimEventLoopMgr::drainScheduler
StatusCode drainScheduler(int &finishedEvents)
Drain the scheduler from all actions that may be queued.
Definition: HiveSlimEventLoopMgr.cpp:590
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
HistogramAgent
HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store tha...
Definition: HistogramAgent.h:17
HiveSlimEventLoopMgr::m_whiteboard
SmartIF< IHiveWhiteBoard > m_whiteboard
Reference to the Whiteboard.
Definition: HiveSlimEventLoopMgr.h:48
IDataManagerSvc::setRoot
virtual StatusCode setRoot(std::string root_name, DataObject *pObject)=0
Initialize data store for new event by giving new event path.
HiveSlimEventLoopMgr::m_schedulerSvc
SmartIF< IScheduler > m_schedulerSvc
A shortcut for the scheduler.
Definition: HiveSlimEventLoopMgr.h:59
IHiveWhiteBoard::freeSlots
virtual unsigned int freeSlots()=0
Get free slots number.
CommonMessagingBase::verbose
MsgStream & verbose() const
shortcut for the method msgStream(MSG::VERBOSE)
Definition: CommonMessaging.h:118
HiveSlimEventLoopMgr::m_scheduledStop
bool m_scheduledStop
Scheduled stop of event processing.
Definition: HiveSlimEventLoopMgr.h:71
std::binary_search
T binary_search(T...args)
EventContext.h
HiveSlimEventLoopMgr
Definition: HiveSlimEventLoopMgr.h:26
HiveSlimEventLoopMgr::m_eventNumberBlacklist
Gaudi::Property< std::vector< unsigned int > > m_eventNumberBlacklist
Definition: HiveSlimEventLoopMgr.h:35
std::chrono::duration_cast
T duration_cast(T...args)
std::vector::end
T end(T...args)
IProperty::getProperty
virtual StatusCode getProperty(Gaudi::Details::PropertyBase *p) const =0
Get the property by property.
IConverter::createRep
virtual StatusCode createRep(DataObject *pObject, IOpaqueAddress *&refpAddress)=0
Convert the transient object to the requested representation.
IScheduler.h
EventContext
This class represents an entry point to all the event specific data.
Definition: EventContext.h:24
HiveSlimEventLoopMgr::m_appMgrProperty
SmartIF< IProperty > m_appMgrProperty
Property interface of ApplicationMgr.
Definition: HiveSlimEventLoopMgr.h:54
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
Gaudi::ReturnCode::ScheduledStop
constexpr int ScheduledStop
Definition: AppReturnCode.h:27
System::kByte
Definition: Memory.h:56
EventContext::evt
ContextEvt_t evt() const
Definition: EventContext.h:39
std::string
STL class.
Incident.h
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:82
IService::sysInitialize
virtual StatusCode sysInitialize()=0
Initialize Service.
HiveSlimEventLoopMgr::m_warnings
Gaudi::Property< bool > m_warnings
Definition: HiveSlimEventLoopMgr.h:32
DataSvc.h
ISvcLocator::service
StatusCode service(const Gaudi::Utils::TypeNameString &name, T *&svc, bool createIf=true)
Templated method to access a service by name.
Definition: ISvcLocator.h:79
std::vector::push_back
T push_back(T...args)
HiveSlimEventLoopMgr::finalize
StatusCode finalize() override
implementation of IService::finalize
Definition: HiveSlimEventLoopMgr.cpp:240
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
SvcFactory.h
HiveSlimEventLoopMgr::stopRun
StatusCode stopRun() override
implementation of IEventProcessor::stopRun()
Definition: HiveSlimEventLoopMgr.cpp:412
IHiveWhiteBoard::selectStore
virtual StatusCode selectStore(size_t partitionIndex)=0
Activate an given &#39;slot&#39; for all subsequent calls within the same thread id.
IIncidentSvc::fireIncident
virtual void fireIncident(const Incident &incident)=0
Fire an Incident.
IDataManagerSvc.h
IDataProviderSvc.h
HiveSlimEventLoopMgr::~HiveSlimEventLoopMgr
~HiveSlimEventLoopMgr() override
Standard Destructor.
Definition: HiveSlimEventLoopMgr.cpp:52
std::chrono::high_resolution_clock
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:109
IHiveWhiteBoard::clearStore
virtual StatusCode clearStore(size_t partitionIndex)=0
Clear an given &#39;slot&#39;.
HiveSlimEventLoopMgr.h
IAlgResourcePool::endRun
virtual StatusCode endRun()=0
End Run.
IIncidentSvc.h
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
GaudiException.h
HiveSlimEventLoopMgr::executeRun
StatusCode executeRun(int maxevt) override
implementation of IEventProcessor::executeRun()
Definition: HiveSlimEventLoopMgr.cpp:377
SmartIF.h
HiveSlimEventLoopMgr::createEventContext
StatusCode createEventContext(EventContext *&eventContext, int createdEvents)
Create event context.
Definition: HiveSlimEventLoopMgr.cpp:573
EventStatus::Success
Definition: IAlgExecStateSvc.h:67
IRegistry
The IRegistry represents the entry door to the environment any data object residing in a transient da...
Definition: IRegistry.h:22
IScheduler::pushNewEvent
virtual StatusCode pushNewEvent(EventContext *eventContext)=0
Make an event available to the scheduler.
DECLARE_SERVICE_FACTORY
#define DECLARE_SERVICE_FACTORY(x)
Definition: Service.h:211
HiveSlimEventLoopMgr::getEventRoot
StatusCode getEventRoot(IOpaqueAddress *&refpAddr)
Create event address using event selector.
Definition: HiveSlimEventLoopMgr.cpp:522
StatusCode::isRecoverable
bool isRecoverable() const
Definition: StatusCode.h:62
IEvtSelector::releaseContext
virtual StatusCode releaseContext(Context *&) const =0
Release the Context object.
Clock
std::chrono::high_resolution_clock Clock
Definition: ITimelineSvc.h:10
HistogramAgent::selectedObjects
IDataSelector * selectedObjects()
Return the set of selected DataObjects.
Definition: HistogramAgent.h:30
Gaudi::setAppReturnCode
StatusCode setAppReturnCode(SmartIF< IProperty > &appmgr, int value, bool force=false)
Set the application return code.
Definition: AppReturnCode.h:51
LIKELY
#define LIKELY(x)
Definition: Kernel.h:127
AppReturnCode.h
GaudiPython.Bindings.DataObject
DataObject
Definition: Bindings.py:55
IAlgExecStateSvc::reset
virtual void reset(const EventContext &ctx)=0
System::mappedMemory
GAUDI_API long mappedMemory(MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
Basic Process Information: priority boost.
Definition: Memory.cpp:204
std::vector::size
T size(T...args)
HiveSlimEventLoopMgr::initialize
StatusCode initialize() override
implementation of IService::initialize
Definition: HiveSlimEventLoopMgr.cpp:65
std::vector< DataObject * >
Memory.h
IAlgResourcePool::beginRun
virtual StatusCode beginRun()=0
Begin Run.
HiveSlimEventLoopMgr::m_algExecStateSvc
SmartIF< IAlgExecStateSvc > m_algExecStateSvc
Reference to the AlgExecStateSvc.
Definition: HiveSlimEventLoopMgr.h:52
std::unique_ptr< Incident >
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:115
IConversionSvc.h
HiveSlimEventLoopMgr::m_histoPersSvc
SmartIF< IConversionSvc > m_histoPersSvc
Reference to the Histogram Persistency Service.
Definition: HiveSlimEventLoopMgr.h:46
IHiveWhiteBoard::allocateStore
virtual size_t allocateStore(int evtnumber)=0
Allocate a store partition for new event.
HiveSlimEventLoopMgr::m_schedulerName
Gaudi::Property< std::string > m_schedulerName
Definition: HiveSlimEventLoopMgr.h:33
SmartIF::isValid
bool isValid() const
Allow for check if smart pointer is valid.
Definition: SmartIF.h:68
std::vector::begin
T begin(T...args)
time_point
Clock::time_point time_point
Definition: ITimelineSvc.h:11
std::chrono::high_resolution_clock::now
T now(T...args)
IScheduler::tryPopFinishedEvent
virtual StatusCode tryPopFinishedEvent(EventContext *&eventContext)=0
Try to retrieve a finished event from the scheduler.
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
IAlgExecStateSvc::eventStatus
virtual const EventStatus::Status & eventStatus(const EventContext &ctx) const =0
HiveSlimEventLoopMgr::m_histoDataMgrSvc
SmartIF< IDataManagerSvc > m_histoDataMgrSvc
Reference to the Histogram Data Service.
Definition: HiveSlimEventLoopMgr.h:44
HiveSlimEventLoopMgr::m_evtSelector
SmartIF< IEvtSelector > m_evtSelector
Reference to the Event Selector.
Definition: HiveSlimEventLoopMgr.h:40
IHiveWhiteBoard::freeStore
virtual StatusCode freeStore(size_t partitionIndex)=0
Free a store partition.
CommonMessaging
Definition: CommonMessaging.h:62
HiveSlimEventLoopMgr::reinitialize
StatusCode reinitialize() override
implementation of IService::reinitialize
Definition: HiveSlimEventLoopMgr.cpp:167
IEvtSelector::next
virtual StatusCode next(Context &c) const =0
Fetch the next event or the first event if it will be use soon after the creation of the context...
IAlgManager.h
IEvtSelector.h
IIncidentListener.h
Service::service
StatusCode service(const std::string &name, const T *&psvc, bool createIf=true) const
Access a service by name, creating it if it doesn&#39;t already exist.
Definition: Service.h:85
IChronoStatSvc.h
std::sort
T sort(T...args)
IEvtSelector::createContext
virtual StatusCode createContext(Context *&c) const =0
Create and return a context object that will keep track of the state of selection.
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:92
HistogramAgent.h
IEvtSelector::createAddress
virtual StatusCode createAddress(const Context &c, IOpaqueAddress *&iop) const =0
Create an IOpaqueAddress object from the event fetched.
StatusCode::FAILURE
Definition: StatusCode.h:29
IOpaqueAddress
Opaque address interface definition.
Definition: IOpaqueAddress.h:23
maxevt
int maxevt
Definition: Bootstrap.cpp:279
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:84
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:100
Gaudi::ReturnCode::Success
constexpr int Success
Definition: AppReturnCode.h:18
HiveSlimEventLoopMgr::m_algResourcePool
SmartIF< IAlgResourcePool > m_algResourcePool
Reference to the Algorithm resource pool.
Definition: HiveSlimEventLoopMgr.h:50
HiveSlimEventLoopMgr::executeEvent
StatusCode executeEvent(void *par) override
implementation of IEventProcessor::executeEvent(void* par)
Definition: HiveSlimEventLoopMgr.cpp:312
IRegistry::address
virtual IOpaqueAddress * address() const =0
Retrieve opaque storage address.
IConverter::fillRepRefs
virtual StatusCode fillRepRefs(IOpaqueAddress *pAddress, DataObject *pObject)=0
Resolve the references of the converted object.
HiveSlimEventLoopMgr::nextEvent
StatusCode nextEvent(int maxevt) override
implementation of IService::nextEvent
Definition: HiveSlimEventLoopMgr.cpp:430
IScheduler::freeSlots
virtual unsigned int freeSlots()=0
Get the free event processing slots.
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:292
IScheduler::popFinishedEvent
virtual StatusCode popFinishedEvent(EventContext *&eventContext)=0
Retrieve a finished event from the scheduler.
HiveSlimEventLoopMgr::m_endEventFired
bool m_endEventFired
Flag to avoid to fire the EnvEvent incident twice in a row (and also not before the first event) ...
Definition: HiveSlimEventLoopMgr.h:57
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
HiveSlimEventLoopMgr::m_blackListBS
boost::dynamic_bitset * m_blackListBS
Definition: HiveSlimEventLoopMgr.h:78
HiveSlimEventLoopMgr::stop
StatusCode stop() override
implementation of IService::stop
Definition: HiveSlimEventLoopMgr.cpp:226
DataObject.h
StatusCode::RECOVERABLE
Definition: StatusCode.h:29
HiveSlimEventLoopMgr::m_evtContext
IEvtSelector::Context * m_evtContext
Event Iterator.
Definition: HiveSlimEventLoopMgr.h:42