| The Gaudi Framework v32r1 (f65d50dc)

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