| The Gaudi Framework v30r0 (c919700c)

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

- File List
- File Members

MinimalEventLoopMgr.cpp
Go to the documentation of this file.
1 #define GAUDIKERNEL_MINIMALEVENTLOOPMGR_CPP
2
3 #include "GaudiKernel/AppReturnCode.h"
4 #include "GaudiKernel/GaudiException.h"
5 #include "GaudiKernel/IAlgManager.h"
6 #include "GaudiKernel/IAlgorithm.h"
7 #include "GaudiKernel/IIncidentListener.h"
8 #include "GaudiKernel/IIncidentSvc.h"
9 #include "GaudiKernel/Incident.h"
10 #include "GaudiKernel/MsgStream.h"
11 #include "GaudiKernel/SmartIF.h"
12 #include "GaudiKernel/ThreadGaudi.h"
13 #include "GaudiKernel/ThreadLocalContext.h"
14 #include "GaudiKernel/TypeNameString.h"
15
16 #include "GaudiKernel/MinimalEventLoopMgr.h"
17
18 #include <algorithm>
19
20 namespace
21 {
22 class AbortEventListener : public implements<IIncidentListener>
23 {
24 public:
25 AbortEventListener( bool& flag, std::string& source ) : m_flag( flag ), m_source( source )
26 {
27 addRef(); // Initial count set to 1
28 }
29 ~AbortEventListener() override = default;
31 void handle( const Incident& i ) override
32 {
33 if ( i.type() == IncidentType::AbortEvent ) {
34 m_flag = true;
35 m_source = i.source();
36 }
37 }
38
39 private:
41 bool& m_flag;
43 std::string& m_source;
44 };
45 }
46
47 #define ON_DEBUG if ( UNLIKELY( outputLevel() <= MSG::DEBUG ) )
48 #define ON_VERBOSE if ( UNLIKELY( outputLevel() <= MSG::VERBOSE ) )
49
50 #define DEBMSG ON_DEBUG debug()
51 #define VERMSG ON_VERBOSE verbose()
52
53 //--------------------------------------------------------------------------------------------
54 // Standard Constructor
55 //--------------------------------------------------------------------------------------------
56 MinimalEventLoopMgr::MinimalEventLoopMgr( const std::string& nam, ISvcLocator* svcLoc )
57 : base_class( nam, svcLoc ), m_appMgrUI( svcLoc )
58 {
59 m_topAlgNames.declareUpdateHandler( &MinimalEventLoopMgr::topAlgHandler, this );
60 m_outStreamNames.declareUpdateHandler( &MinimalEventLoopMgr::outStreamHandler, this );
61 }
62
63 //--------------------------------------------------------------------------------------------
64 // implementation of IAppMgrUI::initialize
65 //--------------------------------------------------------------------------------------------
66 StatusCode MinimalEventLoopMgr::initialize()
67 {
68
69 if ( !m_appMgrUI ) return StatusCode::FAILURE;
70
71 StatusCode sc = Service::initialize();
72 if ( !sc.isSuccess() ) {
73 error() << "Failed to initialize Service Base class." << endmsg;
74 return StatusCode::FAILURE;
75 }
76
77 auto prpMgr = serviceLocator()->as<IProperty>();
78 if ( !prpMgr ) {
79 error() << "Error retrieving AppMgr interface IProperty." << endmsg;
80 return StatusCode::FAILURE;
81 }
82 if ( m_topAlgNames.value().empty() ) {
83 setProperty( prpMgr->getProperty( "TopAlg" ) ).ignore();
84 }
85 if ( m_outStreamNames.value().empty() ) {
86 setProperty( prpMgr->getProperty( "OutStream" ) ).ignore();
87 }
88
89 // Get the references to the services that are needed by the ApplicationMgr itself
90 m_incidentSvc = serviceLocator()->service( "IncidentSvc" );
91 if ( !m_incidentSvc ) {
92 fatal() << "Error retrieving IncidentSvc." << endmsg;
93 return StatusCode::FAILURE;
94 }
95
96 m_abortEventListener = new AbortEventListener( m_abortEvent, m_abortEventSource );
97 m_incidentSvc->addListener( m_abortEventListener, IncidentType::AbortEvent );
98
99 // The state is changed at this moment to allow decodeXXXX() to do something
100 m_state = INITIALIZED;
101
102 // Get WhiteBoard interface if implemented by EventDataSvc
103 m_WB = service( "EventDataSvc" );
104
105 // setup the default EventContext with slot 0
106 Gaudi::Hive::setCurrentContextId( Gaudi::Hive::ContextIdType( 0 ) );
107
108 //--------------------------------------------------------------------------------------------
109 // Create output streams. Do not initialize them yet.
110 // The state is updated temporarily in order to enable the handler, which
111 // is also triggered by a change to the "OutputStream" Property.
112 //--------------------------------------------------------------------------------------------
113 sc = decodeOutStreams();
114 if ( !sc.isSuccess() ) {
115 error() << "Failed to initialize Output streams." << endmsg;
116 m_state = CONFIGURED;
117 return sc;
118 }
119 //--------------------------------------------------------------------------------------------
120 // Create all needed Top Algorithms. Do not initialize them yet.
121 // The state is updated temporarily in order to enable the handler, which
122 // is also triggered by a change to the "TopAlg" Property.
123 //--------------------------------------------------------------------------------------------
124 sc = decodeTopAlgs();
125 if ( !sc.isSuccess() ) {
126 error() << "Failed to initialize Top Algorithms streams." << endmsg;
127 m_state = CONFIGURED;
128 return sc;
129 }
130
131 // Initialize all the new TopAlgs. In fact Algorithms are protected against
132 // getting initialized twice.
133 for ( auto& ita : m_topAlgList ) {
134 sc = ita->sysInitialize();
135 if ( !sc.isSuccess() ) {
136 error() << "Unable to initialize Algorithm: " << ita->name() << endmsg;
137 return sc;
138 }
139 }
140 for ( auto& ita : m_outStreamList ) {
141 sc = ita->sysInitialize();
142 if ( !sc.isSuccess() ) {
143 error() << "Unable to initialize Output Stream: " << ita->name() << endmsg;
144 return sc;
145 }
146 }
147
148 // get hold of the Algorithm Execution State mgr
149 m_aess = serviceLocator()->service( "AlgExecStateSvc" );
150 if ( !m_aess ) {
151 fatal() << "Error retrieving AlgExecStateSvc." << endmsg;
152 return StatusCode::FAILURE;
153 }
154
155 if ( m_printCFExp && !m_topAlgList.empty() ) {
156 info() << "Control Flow Expression:" << endmsg;
157 std::stringstream expr;
158 auto& first = m_topAlgList.front();
159 for ( auto& ialg : m_topAlgList ) {
160 if ( ialg != first ) expr << " >> ";
161 ialg->toControlFlowExpression( expr );
162 }
163 info() << expr.str() << endmsg;
164 }
165 return StatusCode::SUCCESS;
166 }
167 //--------------------------------------------------------------------------------------------
168 // implementation of IAppMgrUI::start
169 //--------------------------------------------------------------------------------------------
170 StatusCode MinimalEventLoopMgr::start()
171 {
172
173 StatusCode sc = Service::start();
174 if ( !sc.isSuccess() ) return sc;
175
176 // Start all the new TopAlgs. In fact Algorithms are protected against getting
177 // started twice.
178 for ( auto& ita : m_topAlgList ) {
179 sc = ita->sysStart();
180 if ( !sc.isSuccess() ) {
181 error() << "Unable to start Algorithm: " << ita->name() << endmsg;
182 return sc;
183 }
184 }
185 for ( auto& ita : m_outStreamList ) {
186 sc = ita->sysStart();
187 if ( !sc.isSuccess() ) {
188 error() << "Unable to start Output Stream: " << ita->name() << endmsg;
189 return sc;
190 }
191 }
192 return StatusCode::SUCCESS;
193 }
194 //--------------------------------------------------------------------------------------------
195 // implementation of IAppMgrUI::stop
196 //--------------------------------------------------------------------------------------------
197 StatusCode MinimalEventLoopMgr::stop()
198 {
199
200 StatusCode sc( StatusCode::SUCCESS, true );
201
202 // Stop all the TopAlgs. In fact Algorithms are protected against getting
203 // stopped twice.
204 for ( auto& ita : m_topAlgList ) {
205 sc = ita->sysStop();
206 if ( !sc.isSuccess() ) {
207 error() << "Unable to stop Algorithm: " << ita->name() << endmsg;
208 return sc;
209 }
210 }
211 for ( auto& ita : m_outStreamList ) {
212 sc = ita->sysStop();
213 if ( !sc.isSuccess() ) {
214 error() << "Unable to stop Output Stream: " << ita->name() << endmsg;
215 return sc;
216 }
217 }
218
219 return Service::stop();
220 }
221
222 //--------------------------------------------------------------------------------------------
223 // implementation of IService::reinitialize
224 //--------------------------------------------------------------------------------------------
225 StatusCode MinimalEventLoopMgr::reinitialize()
226 {
227 StatusCode sc = StatusCode::SUCCESS;
228
229 // Reinitialize all the TopAlgs.
230 for ( auto& ita : m_topAlgList ) {
231 sc = ita->sysReinitialize();
232 if ( !sc.isSuccess() ) {
233 error() << "Unable to reinitialize Algorithm: " << ita->name() << endmsg;
234 return sc;
235 }
236 }
237 for ( auto& ita : m_outStreamList ) {
238 sc = ita->sysReinitialize();
239 if ( !sc.isSuccess() ) {
240 error() << "Unable to reinitialize Output Stream: " << ita->name() << endmsg;
241 return sc;
242 }
243 }
244
245 return sc;
246 }
247 //--------------------------------------------------------------------------------------------
248 // implementation of IService::restart
249 //--------------------------------------------------------------------------------------------
250 StatusCode MinimalEventLoopMgr::restart()
251 {
252 StatusCode sc = StatusCode::SUCCESS;
253
254 // Restart all the TopAlgs.
255 for ( auto& ita : m_topAlgList ) {
256 m_aess->resetErrorCount( ita );
257 sc = ita->sysRestart();
258 if ( !sc.isSuccess() ) {
259 error() << "Unable to restart Algorithm: " << ita->name() << endmsg;
260 return sc;
261 }
262 }
263 for ( auto& ita : m_outStreamList ) {
264 m_aess->resetErrorCount( ita );
265 sc = ita->sysRestart();
266 if ( !sc.isSuccess() ) {
267 error() << "Unable to restart Output Stream: " << ita->name() << endmsg;
268 return sc;
269 }
270 }
271
272 return sc;
273 }
274
275 //--------------------------------------------------------------------------------------------
276 // implementation of IService::finalize
277 //--------------------------------------------------------------------------------------------
278 StatusCode MinimalEventLoopMgr::finalize()
279 {
280 StatusCode sc = StatusCode::SUCCESS;
281 StatusCode scRet = StatusCode::SUCCESS;
282 // Call the finalize() method of all top algorithms
283 for ( auto& ita : m_topAlgList ) {
284 sc = ita->sysFinalize();
285 if ( !sc.isSuccess() ) {
286 scRet = StatusCode::FAILURE;
287 warning() << "Finalization of algorithm " << ita->name() << " failed" << endmsg;
288 }
289 }
290 // Call the finalize() method of all Output streams
291 for ( auto& ita : m_outStreamList ) {
292 sc = ita->sysFinalize();
293 if ( !sc.isSuccess() ) {
294 scRet = StatusCode::FAILURE;
295 warning() << "Finalization of algorithm " << ita->name() << " failed" << endmsg;
296 }
297 }
298 // release all top algorithms
299 auto algMan = serviceLocator()->as<IAlgManager>();
300 for ( auto& ita : m_topAlgList ) {
301 if ( algMan->removeAlgorithm( ita ).isFailure() ) {
302 scRet = StatusCode::FAILURE;
303 warning() << "Problems removing Algorithm " << ita->name() << endmsg;
304 }
305 }
306 m_topAlgList.clear();
307 m_outStreamList.clear();
308 if ( sc.isSuccess() ) m_state = FINALIZED;
309
310 m_incidentSvc->removeListener( m_abortEventListener, IncidentType::AbortEvent );
311 m_abortEventListener.reset();
312
313 m_incidentSvc.reset();
314 m_appMgrUI.reset();
315
316 sc = Service::finalize();
317
318 if ( sc.isFailure() ) {
319 scRet = StatusCode::FAILURE;
320 error() << "Problems finalizing Service base class" << endmsg;
321 }
322
323 return scRet;
324 }
325
326 //--------------------------------------------------------------------------------------------
327 // implementation of IAppMgrUI::nextEvent
328 //--------------------------------------------------------------------------------------------
329 StatusCode MinimalEventLoopMgr::nextEvent( int /* maxevt */ )
330 {
331 error() << "This method cannot be called on an object of type " << System::typeinfoName( typeid( *this ) ) << endmsg;
332 return StatusCode::FAILURE;
333 }
334
335 //--------------------------------------------------------------------------------------------
336 // IEventProcessing::executeRun
337 //--------------------------------------------------------------------------------------------
338 StatusCode MinimalEventLoopMgr::executeRun( int maxevt )
339 {
340 StatusCode sc;
341 bool eventfailed = false;
342
343 // Call the beginRun() method of all top algorithms
344 for ( auto& ita : m_topAlgList ) {
345 sc = ita->sysBeginRun();
346 if ( !sc.isSuccess() ) {
347 warning() << "beginRun() of algorithm " << ita->name() << " failed" << endmsg;
348 eventfailed = true;
349 }
350 }
351
352 // Call now the nextEvent(...)
353 sc = nextEvent( maxevt );
354 if ( !sc.isSuccess() ) eventfailed = true;
355
356 // Call the endRun() method of all top algorithms
357 for ( auto& ita : m_topAlgList ) {
358 sc = ita->sysEndRun();
359 if ( !sc.isSuccess() ) {
360 warning() << "endRun() of algorithm " << ita->name() << " failed" << endmsg;
361 eventfailed = true;
362 }
363 }
364
365 return eventfailed ? StatusCode::FAILURE : StatusCode::SUCCESS;
366 }
367
368 namespace
369 {
372 class RetCodeGuard
373 {
374 public:
375 inline RetCodeGuard( SmartIF<IProperty> appmgr, int retcode )
376 : m_appmgr( std::move( appmgr ) ), m_retcode( retcode )
377 {
378 }
379 inline void ignore() { m_retcode = Gaudi::ReturnCode::Success; }
380 inline ~RetCodeGuard()
381 {
382 if ( UNLIKELY( Gaudi::ReturnCode::Success != m_retcode ) ) {
383 Gaudi::setAppReturnCode( m_appmgr, m_retcode );
384 }
385 }
386
387 private:
388 SmartIF<IProperty> m_appmgr;
389 int m_retcode;
390 };
391 }
392 //--------------------------------------------------------------------------------------------
393 // Implementation of IEventProcessor::executeEvent(void* par)
394 //--------------------------------------------------------------------------------------------
395 StatusCode MinimalEventLoopMgr::executeEvent( void* /* par */ )
396 {
397 bool eventfailed = false;
398
399 // reset state of ALL "known" algorithms
400 // (before we were reseting only the topalgs)
401 const EventContext& context = Gaudi::Hive::currentContext();
402 m_aess->reset( context );
403
404 // Set event number in the context
405 Gaudi::Hive::setCurrentContextEvt( m_nevt );
406
407 // select the appropriate store
408 if ( m_WB.isValid() ) m_WB->selectStore( context.slot() ).ignore();
409
410 // Get the IProperty interface of the ApplicationMgr to pass it to RetCodeGuard
411 const auto appmgr = serviceLocator()->as<IProperty>();
412 // Call the execute() method of all top algorithms
413 for ( auto& ita : m_topAlgList ) {
414 StatusCode sc( StatusCode::FAILURE );
415 AlgExecState& algState = m_aess->algExecState( ita, context );
416 try {
417 if ( UNLIKELY( m_abortEvent ) ) {
418 DEBMSG << "AbortEvent incident fired by " << m_abortEventSource << endmsg;
419 m_abortEvent = false;
420 sc.ignore();
421 break;
422 }
423 RetCodeGuard rcg( appmgr, Gaudi::ReturnCode::UnhandledException );
424 algState.setState( AlgExecState::State::Executing );
425 sc = ita->sysExecute( context );
426 rcg.ignore(); // disarm the guard
427 } catch ( const GaudiException& Exception ) {
428 fatal() << ".executeEvent(): Exception with tag=" << Exception.tag() << " thrown by " << ita->name() << endmsg;
429 error() << Exception << endmsg;
430 } catch ( const std::exception& Exception ) {
431 fatal() << ".executeEvent(): Standard std::exception thrown by " << ita->name() << endmsg;
432 error() << Exception.what() << endmsg;
433 } catch ( ... ) {
434 fatal() << ".executeEvent(): UNKNOWN Exception thrown by " << ita->name() << endmsg;
435 }
436
437 algState.setState( AlgExecState::State::Done );
438 algState.setExecStatus( sc );
439
440 if ( UNLIKELY( !sc.isSuccess() ) ) {
441 warning() << "Execution of algorithm " << ita->name() << " failed" << endmsg;
442 eventfailed = true;
443 }
444 }
445
446 m_aess->updateEventStatus( eventfailed, context );
447
448 // ensure that the abortEvent flag is cleared before the next event
449 if ( UNLIKELY( m_abortEvent ) ) {
450 DEBMSG << "AbortEvent incident fired by " << m_abortEventSource << endmsg;
451 m_abortEvent = false;
452 }
453
454 // Call the execute() method of all output streams
455 for ( auto& ito : m_outStreamList ) {
456 AlgExecState& state = m_aess->algExecState( ito, context );
457 state.setState( AlgExecState::State::Executing );
458 state.setFilterPassed( true );
459 StatusCode sc = ito->sysExecute( context );
460 state.setState( AlgExecState::State::Done, sc );
461 if ( UNLIKELY( !sc.isSuccess() ) ) {
462 warning() << "Execution of output stream " << ito->name() << " failed" << endmsg;
463 eventfailed = true;
464 }
465 }
466
467 m_nevt++;
468
469 // Check if there was an error processing current event
470 if ( UNLIKELY( eventfailed ) ) {
471 error() << "Error processing event loop." << endmsg;
472 std::ostringstream ost;
473 m_aess->dump( ost, context );
474 debug() << "Dumping AlgExecStateSvc status:\n" << ost.str() << endmsg;
475 return StatusCode( StatusCode::FAILURE, true );
476 }
477
478 return StatusCode( StatusCode::SUCCESS, true );
479 }
480 //--------------------------------------------------------------------------------------------
481 // Implementation of IEventProcessor::stopRun()
482 //--------------------------------------------------------------------------------------------
483 StatusCode MinimalEventLoopMgr::stopRun()
484 {
485 // Set the application return code
486 auto appmgr = serviceLocator()->as<IProperty>();
487 if ( Gaudi::setAppReturnCode( appmgr, Gaudi::ReturnCode::ScheduledStop ).isFailure() ) {
488 error() << "Could not set return code of the application (" << Gaudi::ReturnCode::ScheduledStop << ")" << endmsg;
489 }
490 m_scheduledStop = true;
491 return StatusCode::SUCCESS;
492 }
493
494 //--------------------------------------------------------------------------------------------
495 // Top algorithm List handler
496 //--------------------------------------------------------------------------------------------
497 void MinimalEventLoopMgr::topAlgHandler( Gaudi::Details::PropertyBase& /* theProp */ )
498 {
499 if ( !( decodeTopAlgs() ).isSuccess() ) {
500 throw GaudiException( "Failed to initialize Top Algorithms streams.", "MinimalEventLoopMgr::topAlgHandler",
501 StatusCode::FAILURE );
502 }
503 }
504
505 //--------------------------------------------------------------------------------------------
506 // decodeTopAlgNameList & topAlgNameListHandler
507 //--------------------------------------------------------------------------------------------
508 StatusCode MinimalEventLoopMgr::decodeTopAlgs()
509 {
510 StatusCode sc = StatusCode::SUCCESS;
511 if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
512 auto algMan = serviceLocator()->as<IAlgManager>();
513 if ( algMan ) {
514 // Reset the existing Top Algorithm List
515 m_topAlgList.clear();
516 m_topAlgList.reserve( m_topAlgNames.value().size() );
517 for ( const auto& it : m_topAlgNames.value() ) {
518 Gaudi::Utils::TypeNameString item{it};
519 // Got the type and name. Now creating the algorithm, avoiding duplicate creation.
520 std::string item_name = item.name() + getGaudiThreadIDfromName( name() );
521 const bool CREATE = false;
522 SmartIF<IAlgorithm> alg = algMan->algorithm( item_name, CREATE );
523 if ( alg ) {
524 DEBMSG << "Top Algorithm " << item_name << " already exists" << endmsg;
525 } else {
526 DEBMSG << "Creating Top Algorithm " << item.type() << " with name " << item_name << endmsg;
527 IAlgorithm* ialg = nullptr;
528 StatusCode sc1 = algMan->createAlgorithm( item.type(), item_name, ialg );
529 if ( !sc1.isSuccess() ) {
530 error() << "Unable to create Top Algorithm " << item.type() << " with name " << item_name << endmsg;
531 return sc1;
532 }
533 alg = ialg; // manage reference counting
534 }
535 m_topAlgList.push_back( alg );
536 }
537 return sc;
538 }
539 sc = StatusCode::FAILURE;
540 }
541 return sc;
542 }
543
544 //--------------------------------------------------------------------------------------------
545 // Output stream List handler
546 //--------------------------------------------------------------------------------------------
547 void MinimalEventLoopMgr::outStreamHandler( Gaudi::Details::PropertyBase& /* theProp */ )
548 {
549 if ( !( decodeOutStreams() ).isSuccess() ) {
550 throw GaudiException( "Failed to initialize output streams.", "MinimalEventLoopMgr::outStreamHandler",
551 StatusCode::FAILURE );
552 }
553 }
554
555 //--------------------------------------------------------------------------------------------
556 // decodeOutStreamNameList & outStreamNameListHandler
557 //--------------------------------------------------------------------------------------------
558 StatusCode MinimalEventLoopMgr::decodeOutStreams()
559 {
560 StatusCode sc = StatusCode::SUCCESS;
561 if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
562 auto algMan = serviceLocator()->as<IAlgManager>();
563 if ( algMan ) {
564 // Reset the existing Top Algorithm List
565 m_outStreamList.clear();
566 for ( const auto& it : m_outStreamNames.value() ) {
567 Gaudi::Utils::TypeNameString item( it, m_outStreamType );
568 const bool CREATE = false;
569 SmartIF<IAlgorithm> os = algMan->algorithm( item, CREATE );
570 if ( os ) {
571 DEBMSG << "Output Stream " << item.name() << " already exists" << endmsg;
572 } else {
573 DEBMSG << "Creating Output Stream " << it << endmsg;
574 IAlgorithm* ios = nullptr;
575 StatusCode sc1 = algMan->createAlgorithm( item.type(), item.name(), ios );
576 if ( !sc1.isSuccess() ) {
577 error() << "Unable to create Output Stream " << it << endmsg;
578 return sc1;
579 }
580 os = ios; // manage reference counting
581 }
582 m_outStreamList.push_back( os );
583 }
584 return sc;
585 }
586 sc = StatusCode::FAILURE;
587 }
588 return sc;
589 }
Gaudi::Hive::ContextIdType
std::size_t ContextIdType
Internal type used for the ContextId.
Definition: ThreadLocalContext.h:15
UNLIKELY
#define UNLIKELY(x)
Definition: Kernel.h:128
StatusCode::SUCCESS
Definition: StatusCode.h:29
MinimalEventLoopMgr::topAlgHandler
void topAlgHandler(Gaudi::Details::PropertyBase &p)
Top algorithm List handler.
Definition: MinimalEventLoopMgr.cpp:497
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:64
SmartIF< IProperty >
implements
Base class used to implement the interfaces.
Definition: implements.h:9
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:22
RetCodeGuard
Helper class to set the application return code in case of early exit (e.g.
Definition: RetCodeGuard.h:9
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:289
MinimalEventLoopMgr::finalize
StatusCode finalize() override
implementation of IService::finalize
Definition: MinimalEventLoopMgr.cpp:278
Incident::type
const std::string & type() const
Access to the incident type.
Definition: Incident.h:41
MinimalEventLoopMgr::m_scheduledStop
bool m_scheduledStop
Scheduled stop of event processing.
Definition: MinimalEventLoopMgr.h:56
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:174
compareRootHistos.state
state
Definition: compareRootHistos.py:424
Gaudi::Hive::setCurrentContextId
GAUDI_API void setCurrentContextId(ContextIdType newId)
Used by the framework to change the value of the current context id.
Definition: ThreadLocalContext.cpp:27
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
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:112
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:336
Service::start
StatusCode start() override
Definition: Service.cpp:137
MinimalEventLoopMgr::m_aess
SmartIF< IAlgExecStateSvc > m_aess
List of top level algorithms.
Definition: MinimalEventLoopMgr.h:49
Incident::source
const std::string & source() const
Access to the source of the incident.
Definition: Incident.h:47
IAlgExecStateSvc::dump
virtual void dump(std::ostringstream &ost, const EventContext &ctx) const =0
IAlgorithm.h
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
ThreadLocalContext.h
MinimalEventLoopMgr::initialize
StatusCode initialize() override
implementation of IService::initialize
Definition: MinimalEventLoopMgr.cpp:66
AlgExecState::setExecStatus
void setExecStatus(const StatusCode &sc=StatusCode::SUCCESS)
Definition: IAlgExecStateSvc.h:43
MinimalEventLoopMgr::INITIALIZED
Definition: MinimalEventLoopMgr.h:43
IAlgManager
The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to s...
Definition: IAlgManager.h:27
MinimalEventLoopMgr::FINALIZED
Definition: MinimalEventLoopMgr.h:43
MinimalEventLoopMgr::CONFIGURED
Definition: MinimalEventLoopMgr.h:43
MinimalEventLoopMgr::outStreamHandler
void outStreamHandler(Gaudi::Details::PropertyBase &p)
Output stream List handler.
Definition: MinimalEventLoopMgr.cpp:547
ISvcLocator::as
SmartIF< IFace > as()
Definition: ISvcLocator.h:109
MinimalEventLoopMgr::decodeTopAlgs
StatusCode decodeTopAlgs()
decodeTopAlgNameList & topAlgNameListHandler
Definition: MinimalEventLoopMgr.cpp:508
EventContext
This class represents an entry point to all the event specific data.
Definition: EventContext.h:24
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
ThreadGaudi.h
std::stringstream
STL class.
MinimalEventLoopMgr::reinitialize
StatusCode reinitialize() override
implementation of IService::reinitialize
Definition: MinimalEventLoopMgr.cpp:225
Gaudi::ReturnCode::ScheduledStop
constexpr int ScheduledStop
Definition: AppReturnCode.h:27
AlgExecState::setState
void setState(State s)
Definition: IAlgExecStateSvc.h:37
std::string
STL class.
MinimalEventLoopMgr::stop
StatusCode stop() override
implementation of IService::stop
Definition: MinimalEventLoopMgr.cpp:197
Incident.h
MinimalEventLoopMgr::m_state
State m_state
State of the object.
Definition: MinimalEventLoopMgr.h:54
Gaudi::ReturnCode::UnhandledException
constexpr int UnhandledException
Definition: AppReturnCode.h:29
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
gaudirun.retcode
retcode
Definition: gaudirun.py:499
std::vector::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
MinimalEventLoopMgr::m_abortEventSource
std::string m_abortEventSource
Source of the AbortEvent incident.
Definition: MinimalEventLoopMgr.h:63
MinimalEventLoopMgr::m_outStreamNames
Gaudi::Property< std::vector< std::string > > m_outStreamNames
Definition: MinimalEventLoopMgr.h:36
IHiveWhiteBoard::selectStore
virtual StatusCode selectStore(size_t partitionIndex)=0
Activate an given &#39;slot&#39; for all subsequent calls within the same thread id.
MinimalEventLoopMgr::m_abortEventListener
SmartIF< IIncidentListener > m_abortEventListener
Instance of the incident listener waiting for AbortEvent.
Definition: MinimalEventLoopMgr.h:58
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:12
MinimalEventLoopMgr::m_topAlgNames
Gaudi::Property< std::vector< std::string > > m_topAlgNames
Definition: MinimalEventLoopMgr.h:35
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:109
MinimalEventLoopMgr::m_WB
SmartIF< IHiveWhiteBoard > m_WB
Definition: MinimalEventLoopMgr.h:120
std::exception::what
T what(T...args)
IIncidentSvc.h
implements::addRef
unsigned long addRef() override
Reference Interface instance.
Definition: implements.h:41
MinimalEventLoopMgr::nextEvent
StatusCode nextEvent(int maxevt) override
implementation of IEventProcessor::nextEvent
Definition: MinimalEventLoopMgr.cpp:329
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
MsgStream::clear
void clear(STATE_TYPE _i=std::ios_base::failbit)
Definition: MsgStream.h:187
std::ostringstream
STL class.
GaudiException.h
SmartIF.h
IAlgExecStateSvc::algExecState
virtual const AlgExecState & algExecState(const Gaudi::StringKey &algName, const EventContext &ctx) const =0
MinimalEventLoopMgr::start
StatusCode start() override
implementation of IService::start
Definition: MinimalEventLoopMgr.cpp:170
Gaudi::Hive::currentContext
GAUDI_API const EventContext & currentContext()
Definition: ThreadLocalContext.cpp:24
std::stringstream::str
T str(T...args)
MinimalEventLoopMgr::stopRun
StatusCode stopRun() override
implementation of IEventProcessor::stopRun( )
Definition: MinimalEventLoopMgr.cpp:483
GaudiException::tag
virtual const std::string & tag() const
name tag for the exception, or exception type
Definition: GaudiException.h:109
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: Property.h:32
Service::stop
StatusCode stop() override
Definition: Service.cpp:130
std::vector::clear
T clear(T...args)
MinimalEventLoopMgr::m_incidentSvc
SmartIF< IIncidentSvc > m_incidentSvc
Reference to the incident service.
Definition: MinimalEventLoopMgr.h:47
std::exception
STL class.
Gaudi::setAppReturnCode
StatusCode setAppReturnCode(SmartIF< IProperty > &appmgr, int value, bool force=false)
Set the application return code.
Definition: AppReturnCode.h:51
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:28
std::move
T move(T...args)
MinimalEventLoopMgr::restart
StatusCode restart() override
implementation of IService::restart
Definition: MinimalEventLoopMgr.cpp:250
IAlgExecStateSvc::updateEventStatus
virtual void updateEventStatus(const bool &b, const EventContext &ctx)=0
AppReturnCode.h
IAlgExecStateSvc::reset
virtual void reset(const EventContext &ctx)=0
MinimalEventLoopMgr::m_outStreamList
ListAlg m_outStreamList
List of output streams.
Definition: MinimalEventLoopMgr.h:52
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:115
MinimalEventLoopMgr.h
SmartIF::isValid
bool isValid() const
Allow for check if smart pointer is valid.
Definition: SmartIF.h:68
Io::CREATE
Definition: IFileMgr.h:31
Gaudi::Utils::TypeNameString::type
const std::string & type() const
Definition: TypeNameString.h:39
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
IIncidentSvc::addListener
virtual void addListener(IIncidentListener *lis, const std::string &type="", long priority=0, bool rethrow=false, bool singleShot=false)=0
Add listener.
TypeNameString.h
CommonMessaging
Definition: CommonMessaging.h:62
Gaudi::Hive::setCurrentContextEvt
GAUDI_API void setCurrentContextEvt(long int evtN)
Definition: ThreadLocalContext.cpp:26
IAlgManager.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
RetCodeGuard::ignore
void ignore()
Definition: RetCodeGuard.h:13
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:92
IIncidentSvc::removeListener
virtual void removeListener(IIncidentListener *lis, const std::string &type="")=0
Remove listener.
StatusCode::FAILURE
Definition: StatusCode.h:29
Gaudi::Utils::TypeNameString::name
const std::string & name() const
Definition: TypeNameString.h:40
DEBMSG
#define DEBMSG
Definition: MinimalEventLoopMgr.cpp:50
MinimalEventLoopMgr::decodeOutStreams
StatusCode decodeOutStreams()
decodeOutStreamNameList & outStreamNameListHandler
Definition: MinimalEventLoopMgr.cpp:558
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
AlgExecState::setFilterPassed
void setFilterPassed(bool f=true)
Definition: IAlgExecStateSvc.h:36
Gaudi::ReturnCode::Success
constexpr int Success
Definition: AppReturnCode.h:18
IProperty
The IProperty is the basic interface for all components which have properties that can be set or get...
Definition: IProperty.h:20
MinimalEventLoopMgr::executeRun
StatusCode executeRun(int maxevt) override
implementation of IEventProcessor::executeRun( )
Definition: MinimalEventLoopMgr.cpp:338
MinimalEventLoopMgr::m_printCFExp
Gaudi::Property< bool > m_printCFExp
Definition: MinimalEventLoopMgr.h:39
getGaudiThreadIDfromName
GAUDI_API std::string getGaudiThreadIDfromName(const std::string &name)
helper function to extract Gaudi Thread ID from thread copy name
Definition: ThreadGaudi.cpp:27
MinimalEventLoopMgr::m_outStreamType
Gaudi::Property< std::string > m_outStreamType
Definition: MinimalEventLoopMgr.h:37
AlgExecState
Definition: IAlgExecStateSvc.h:27
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:292
IAlgExecStateSvc::resetErrorCount
virtual void resetErrorCount(const IAlgorithm *iAlg)=0
MinimalEventLoopMgr::MinimalEventLoopMgr
MinimalEventLoopMgr(const std::string &nam, ISvcLocator *svcLoc)
Standard Constructor.
Definition: MinimalEventLoopMgr.cpp:56
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
MinimalEventLoopMgr::m_appMgrUI
SmartIF< IAppMgrUI > m_appMgrUI
Reference to the IAppMgrUI interface of the application manager.
Definition: MinimalEventLoopMgr.h:45
MinimalEventLoopMgr::executeEvent
StatusCode executeEvent(void *par) override
implementation of IEventProcessor::executeEvent(void* par)
Definition: MinimalEventLoopMgr.cpp:395
MinimalEventLoopMgr::m_topAlgList
ListAlg m_topAlgList
Definition: MinimalEventLoopMgr.h:50
std::vector::reserve
T reserve(T...args)
MinimalEventLoopMgr::m_abortEvent
bool m_abortEvent
Flag signalling that the event being processedhas to be aborted (skip all following top algs)...
Definition: MinimalEventLoopMgr.h:61
MinimalEventLoopMgr::m_nevt
size_t m_nevt
Definition: MinimalEventLoopMgr.h:123