| The Gaudi Framework v28r2p1 (f1a77ff4)

- 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())
409 m_WB->selectStore(context.slot()).ignore();
410
411 // Get the IProperty interface of the ApplicationMgr to pass it to RetCodeGuard
412 const auto appmgr = serviceLocator()->as<IProperty>();
413 // Call the execute() method of all top algorithms
414 for ( auto& ita : m_topAlgList ) {
415 StatusCode sc( StatusCode::FAILURE );
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 sc = ita->sysExecute(context);
425 rcg.ignore(); // disarm the guard
426 } catch ( const GaudiException& Exception ) {
427 fatal() << ".executeEvent(): Exception with tag=" << Exception.tag() << " thrown by " << ita->name() << endmsg;
428 error() << Exception << endmsg;
429 } catch ( const std::exception& Exception ) {
430 fatal() << ".executeEvent(): Standard std::exception thrown by " << ita->name() << endmsg;
431 error() << Exception.what() << endmsg;
432 } catch ( ... ) {
433 fatal() << ".executeEvent(): UNKNOWN Exception thrown by " << ita->name() << endmsg;
434 }
435
436 AlgExecState& state = m_aess->algExecState(ita, context);
437 state.setExecuted(true);
438 state.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.setExecuted(false);
458 state.setFilterPassed(true);
459 StatusCode sc;
460 sc = ito->sysExecute(context);
461 state.setExecStatus(sc);
462 if ( UNLIKELY( !sc.isSuccess() ) ) {
463 warning() << "Execution of output stream " << ito->name() << " failed" << endmsg;
464 eventfailed = true;
465 }
466 }
467
468 m_nevt++;
469
470 // Check if there was an error processing current event
471 if ( UNLIKELY( eventfailed ) ) {
472 error() << "Error processing event loop." << endmsg;
473 std::ostringstream ost;
474 m_aess->dump(ost, context);
475 debug() << "Dumping AlgExecStateSvc status:\n" << ost.str() << endmsg;
476 return StatusCode( StatusCode::FAILURE, true );
477 }
478
479 return StatusCode( StatusCode::SUCCESS, true );
480 }
481 //--------------------------------------------------------------------------------------------
482 // Implementation of IEventProcessor::stopRun()
483 //--------------------------------------------------------------------------------------------
484 StatusCode MinimalEventLoopMgr::stopRun()
485 {
486 // Set the application return code
487 auto appmgr = serviceLocator()->as<IProperty>();
488 if ( Gaudi::setAppReturnCode( appmgr, Gaudi::ReturnCode::ScheduledStop ).isFailure() ) {
489 error() << "Could not set return code of the application (" << Gaudi::ReturnCode::ScheduledStop << ")" << endmsg;
490 }
491 m_scheduledStop = true;
492 return StatusCode::SUCCESS;
493 }
494
495 //--------------------------------------------------------------------------------------------
496 // Top algorithm List handler
497 //--------------------------------------------------------------------------------------------
498 void MinimalEventLoopMgr::topAlgHandler( Gaudi::Details::PropertyBase& /* theProp */ )
499 {
500 if ( !( decodeTopAlgs() ).isSuccess() ) {
501 throw GaudiException( "Failed to initialize Top Algorithms streams.", "MinimalEventLoopMgr::topAlgHandler",
502 StatusCode::FAILURE );
503 }
504 }
505
506 //--------------------------------------------------------------------------------------------
507 // decodeTopAlgNameList & topAlgNameListHandler
508 //--------------------------------------------------------------------------------------------
509 StatusCode MinimalEventLoopMgr::decodeTopAlgs()
510 {
511 StatusCode sc = StatusCode::SUCCESS;
512 if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
513 auto algMan = serviceLocator()->as<IAlgManager>();
514 if ( algMan ) {
515 // Reset the existing Top Algorithm List
516 m_topAlgList.clear();
517 m_topAlgList.reserve( m_topAlgNames.value().size() );
518 for ( const auto& it : m_topAlgNames.value() ) {
519 Gaudi::Utils::TypeNameString item{it};
520 // Got the type and name. Now creating the algorithm, avoiding duplicate creation.
521 std::string item_name = item.name() + getGaudiThreadIDfromName( name() );
522 const bool CREATE = false;
523 SmartIF<IAlgorithm> alg = algMan->algorithm( item_name, CREATE );
524 if ( alg ) {
525 DEBMSG << "Top Algorithm " << item_name << " already exists" << endmsg;
526 } else {
527 DEBMSG << "Creating Top Algorithm " << item.type() << " with name " << item_name << endmsg;
528 IAlgorithm* ialg = nullptr;
529 StatusCode sc1 = algMan->createAlgorithm( item.type(), item_name, ialg );
530 if ( !sc1.isSuccess() ) {
531 error() << "Unable to create Top Algorithm " << item.type() << " with name " << item_name << endmsg;
532 return sc1;
533 }
534 alg = ialg; // manage reference counting
535 }
536 m_topAlgList.push_back( alg );
537 }
538 return sc;
539 }
540 sc = StatusCode::FAILURE;
541 }
542 return sc;
543 }
544
545 //--------------------------------------------------------------------------------------------
546 // Output stream List handler
547 //--------------------------------------------------------------------------------------------
548 void MinimalEventLoopMgr::outStreamHandler( Gaudi::Details::PropertyBase& /* theProp */ )
549 {
550 if ( !( decodeOutStreams() ).isSuccess() ) {
551 throw GaudiException( "Failed to initialize output streams.", "MinimalEventLoopMgr::outStreamHandler",
552 StatusCode::FAILURE );
553 }
554 }
555
556 //--------------------------------------------------------------------------------------------
557 // decodeOutStreamNameList & outStreamNameListHandler
558 //--------------------------------------------------------------------------------------------
559 StatusCode MinimalEventLoopMgr::decodeOutStreams()
560 {
561 StatusCode sc = StatusCode::SUCCESS;
562 if ( CONFIGURED == m_state || INITIALIZED == m_state ) {
563 auto algMan = serviceLocator()->as<IAlgManager>();
564 if ( algMan ) {
565 // Reset the existing Top Algorithm List
566 m_outStreamList.clear();
567 for ( const auto& it : m_outStreamNames.value() ) {
568 Gaudi::Utils::TypeNameString item( it, m_outStreamType );
569 const bool CREATE = false;
570 SmartIF<IAlgorithm> os = algMan->algorithm( item, CREATE );
571 if ( os ) {
572 DEBMSG << "Output Stream " << item.name() << " already exists" << endmsg;
573 } else {
574 DEBMSG << "Creating Output Stream " << it << endmsg;
575 IAlgorithm* ios = nullptr;
576 StatusCode sc1 = algMan->createAlgorithm( item.type(), item.name(), ios );
577 if ( !sc1.isSuccess() ) {
578 error() << "Unable to create Output Stream " << it << endmsg;
579 return sc1;
580 }
581 os = ios; // manage reference counting
582 }
583 m_outStreamList.push_back( os );
584 }
585 return sc;
586 }
587 sc = StatusCode::FAILURE;
588 }
589 return sc;
590 }
Gaudi::Hive::ContextIdType
std::size_t ContextIdType
Internal type used for the ContextId.
Definition: ThreadLocalContext.h:13
MinimalEventLoopMgr::topAlgHandler
void topAlgHandler(Gaudi::Details::PropertyBase &p)
Top algorithm List handler.
Definition: MinimalEventLoopMgr.cpp:498
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:64
StatusCode::SUCCESS
Definition: StatusCode.h:30
SmartIF< IProperty >
implements
Base class used to implement the interfaces.
Definition: implements.h:9
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:23
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
StatusCode::FAILURE
Definition: StatusCode.h:29
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:348
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:31
PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >::setProperty
StatusCode setProperty(const Gaudi::Details::PropertyBase &p) override
set the property form another property
Definition: PropertyHolder.h:210
EventContext::slot
ContextID_t slot() const
Definition: EventContext.h:41
MsgStream.h
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:123
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:299
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:74
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:39
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
UNLIKELY
#define UNLIKELY(x)
Definition: Kernel.h:126
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:548
ISvcLocator::as
SmartIF< IFace > as()
Definition: ISvcLocator.h:106
MinimalEventLoopMgr::decodeTopAlgs
StatusCode decodeTopAlgs()
decodeTopAlgNameList & topAlgNameListHandler
Definition: MinimalEventLoopMgr.cpp:509
EventContext
This class represents an entry point to all the event specific data.
Definition: EventContext.h:25
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:84
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
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:78
gaudirun.retcode
retcode
Definition: gaudirun.py:478
std::vector::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:117
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:120
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:44
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:222
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:484
GaudiException::tag
virtual const std::string & tag() const
name tag for the exception, or exception type
Definition: GaudiException.h:119
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: Property.h:32
AlgExecState::setExecuted
void setExecuted(bool e=true)
Definition: IAlgExecStateSvc.h:38
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:27
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:126
MinimalEventLoopMgr.h
SmartIF::isValid
bool isValid() const
Allow for check if smart pointer is valid.
Definition: SmartIF.h:62
Io::CREATE
Definition: IFileMgr.h:30
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:55
Gaudi::Hive::setCurrentContextEvt
GAUDI_API void setCurrentContextEvt(long int evtN)
Definition: ThreadLocalContext.cpp:28
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:88
IIncidentSvc::removeListener
virtual void removeListener(IIncidentListener *lis, const std::string &type="")=0
Remove listener.
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:559
maxevt
int maxevt
Definition: Bootstrap.cpp:279
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:106
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:111
AlgExecState::setFilterPassed
void setFilterPassed(bool f=true)
Definition: IAlgExecStateSvc.h:37
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:26
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:244
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