| The Gaudi Framework v28r2p1 (f1a77ff4)

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

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
AlgResourcePool Class Reference

The AlgResourcePool is a concrete implementation of the IAlgResourcePool interface. More...

`#include <GaudiHive/AlgResourcePool.h>`

Inheritance diagram for AlgResourcePool:
[legend]
Collaboration diagram for AlgResourcePool:
[legend]

## Public Member Functions
| ~AlgResourcePool () override
StatusCode | start () override
StatusCode | initialize () override
StatusCode | acquireAlgorithm (const std::string &name, IAlgorithm *&algo, bool blocking=false) override
| Acquire a certain algorithm using its name. More...
StatusCode | releaseAlgorithm (const std::string &name, IAlgorithm *&algo) override
| Release a certain algorithm. More...
StatusCode | acquireResource (const std::string &name) override
| Acquire a certain resource. More...
StatusCode | releaseResource (const std::string &name) override
| Release a certrain resource. More...
std::list< IAlgorithm * > | getFlatAlgList () override
std::list< IAlgorithm * > | getTopAlgList () override
StatusCode | beginRun () override
StatusCode | endRun () override
StatusCode | stop () override
virtual concurrency::PrecedenceRulesGraph * | getPRGraph () const
Public Member Functions inherited from extends< Service, IAlgResourcePool >
void * | i_cast (const InterfaceID &tid) const override
| Implementation of IInterface::i_cast. More...
StatusCode | queryInterface (const InterfaceID &ti, void **pp) override
| Implementation of IInterface::queryInterface. More...
std::vector< std::string > | getInterfaceNames () const override
| Implementation of IInterface::getInterfaceNames. More...
| ~extends () override=default
| Virtual destructor. More...
Public Member Functions inherited from Service
const std::string & | name () const override
| Retrieve name of the service. More...
StatusCode | configure () override
StatusCode | initialize () override
StatusCode | start () override
StatusCode | stop () override
StatusCode | finalize () override
StatusCode | terminate () override
Gaudi::StateMachine::State | FSMState () const override
Gaudi::StateMachine::State | targetFSMState () const override
StatusCode | reinitialize () override
StatusCode | restart () override
StatusCode | sysInitialize () override
| Initialize Service. More...
StatusCode | sysStart () override
| Initialize Service. More...
StatusCode | sysStop () override
| Initialize Service. More...
StatusCode | sysFinalize () override
| Finalize Service. More...
StatusCode | sysReinitialize () override
| Re-initialize the Service. More...
StatusCode | sysRestart () override
| Re-initialize the Service. More...
| Service (std::string name, ISvcLocator *svcloc)
| Standard Constructor. More...
SmartIF< ISvcLocator > & | serviceLocator () const override
| Retrieve pointer to service locator. More...
StatusCode | setProperties ()
| Method for setting declared properties to the values specified for the job. More...
template<class T >
StatusCode | service (const std::string &name, const T *&psvc, bool createIf=true) const
| Access a service by name, creating it if it doesn't already exist. More...
template<class T >
StatusCode | service (const std::string &name, T *&psvc, bool createIf=true) const
template<typename IFace = IService>
SmartIF< IFace > | service (const std::string &name, bool createIf=true) const
template<class T >
StatusCode | service (const std::string &svcType, const std::string &svcName, T *&psvc) const
| Access a service by name and type, creating it if it doesn't already exist. More...
template<class T >
StatusCode | declarePrivateTool (ToolHandle< T > &handle, std::string toolTypeAndName="", bool createIf=true)
| Declare used Private tool. More...
template<class T >
StatusCode | declarePublicTool (ToolHandle< T > &handle, std::string toolTypeAndName="", bool createIf=true)
| Declare used Public tool. More...
SmartIF< IAuditorSvc > & | auditorSvc () const
| The standard auditor service.May not be invoked before sysInitialize() has been invoked. More...
Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
| PropertyHolder ()=default
| ~PropertyHolder () override=default
Gaudi::Details::PropertyBase & | declareProperty (Gaudi::Details::PropertyBase &prop)
| Declare a property. More...
Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
| Helper to wrap a regular data member and use it as a regular property. More...
Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, TYPE &value, const std::string &doc="none") const
Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
| Declare a PropertyBase instance setting name and documentation. More...
Gaudi::Details::PropertyBase * | declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
| Declare a remote property. More...
StatusCode | setProperty (const Gaudi::Details::PropertyBase &p) override
| set the property form another property More...
StatusCode | setProperty (const std::string &s) override
| set the property from the formatted string More...
StatusCode | setProperty (const std::string &n, const std::string &v) override
| set the property from name and the value More...
StatusCode | setProperty (const std::string &name, const TYPE &value)
| set the property form the value More...
StatusCode | getProperty (Gaudi::Details::PropertyBase *p) const override
| get the property More...
const Gaudi::Details::PropertyBase & | getProperty (const std::string &name) const override
| get the property by name More...
StatusCode | getProperty (const std::string &n, std::string &v) const override
| convert the property to the string More...
const std::vector< Gaudi::Details::PropertyBase * > & | getProperties () const override
| get all properties More...
bool | hasProperty (const std::string &name) const override
| Return true if we have a property with the given name. More...
| PropertyHolder (const PropertyHolder &)=delete
PropertyHolder & | operator= (const PropertyHolder &)=delete
Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, GaudiHandleBase &ref, const std::string &doc="none")
| Specializations for various GaudiHandles. More...
Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, GaudiHandleArrayBase &ref, const std::string &doc="none")
Gaudi::Details::PropertyBase * | declareProperty (const std::string &name, DataObjectHandleBase &ref, const std::string &doc="none")
Public Member Functions inherited from CommonMessagingBase
virtual | ~CommonMessagingBase ()=default
| Virtual destructor. More...
SmartIF< IMessageSvc > & | msgSvc () const
| The standard message service. More...
MsgStream & | msgStream () const
| Return an uninitialized MsgStream. More...
MsgStream & | msgStream (const MSG::Level level) const
| Predefined configurable message stream for the efficient printouts. More...
MsgStream & | always () const
| shortcut for the method msgStream(MSG::ALWAYS) More...
MsgStream & | fatal () const
| shortcut for the method msgStream(MSG::FATAL) More...
MsgStream & | err () const
| shortcut for the method msgStream(MSG::ERROR) More...
MsgStream & | error () const
| shortcut for the method msgStream(MSG::ERROR) More...
MsgStream & | warning () const
| shortcut for the method msgStream(MSG::WARNING) More...
MsgStream & | info () const
| shortcut for the method msgStream(MSG::INFO) More...
MsgStream & | debug () const
| shortcut for the method msgStream(MSG::DEBUG) More...
MsgStream & | verbose () const
| shortcut for the method msgStream(MSG::VERBOSE) More...
MsgStream & | msg () const
| shortcut for the method msgStream(MSG::INFO) More...
MSG::Level | msgLevel () const
| get the output level from the embedded MsgStream More...
MSG::Level | outputLevel () const __attribute__((deprecated))
| Backward compatibility function for getting the output level. More...
bool | msgLevel (MSG::Level lvl) const
| get the output level from the embedded MsgStream More...
Public Member Functions inherited from extend_interfaces< Interfaces... >
| ~extend_interfaces () override=default
| Virtual destructor. More...

## Private Types
typedef tbb::concurrent_bounded_queue< IAlgorithm * > | concurrentQueueIAlgPtr
typedef std::list< SmartIF< IAlgorithm > > | ListAlg
typedef boost::dynamic_bitset | state_type

## Private Member Functions
StatusCode | decodeTopAlgs ()
| Decode the top alg list. More...
StatusCode | flattenSequencer (Algorithm *sequencer, ListAlg &alglist, const std::string &parentName, unsigned int recursionDepth=0)
| Recursively flatten an algList. More...

## Private Attributes
std::mutex | m_resource_mutex
state_type | m_available_resources {0}
std::map< size_t, concurrentQueueIAlgPtr * > | m_algqueue_map
std::map< size_t, state_type > | m_resource_requirements
std::map< size_t, size_t > | m_n_of_allowed_instances
std::map< size_t, unsigned int > | m_n_of_created_instances
std::map< std::string, unsigned int > | m_resource_indices
Gaudi::Property< bool > | m_lazyCreation {this, "CreateLazily", false, ""}
Gaudi::Property< std::vector< std::string > > | m_topAlgNames
ListAlg | m_algList
| The list of all algorithms created withing the Pool which are not top. More...
ListAlg | m_topAlgList
| The list of top algorithms. More...
ListAlg | m_flatUniqueAlgList
| The flat list of algorithms w/o clones. More...
std::list< IAlgorithm * > | m_flatUniqueAlgPtrList
| The flat list of algorithms w/o clones which is returned. More...
std::list< IAlgorithm * > | m_topAlgPtrList
| The top list of algorithms. More...
concurrency::PrecedenceRulesGraph * | m_PRGraph = nullptr
| OMG yet another hack. More...

## Additional Inherited Members
Public Types inherited from extends< Service, IAlgResourcePool >
using | base_class = extends
| Typedef to this class. More...
using | extend_interfaces_base = extend_interfaces< Interfaces... >
| Typedef to the base of this class. More...
Public Types inherited from Service
typedef Gaudi::PluginService::Factory< IService *, const std::string &, ISvcLocator * > | Factory
Public Types inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
using | PropertyHolderImpl = PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
| Typedef used to refer to this class from derived classes, as in. More...
Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using | base_class = CommonMessaging
Public Types inherited from extend_interfaces< Interfaces... >
using | ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids... >::type
| take union of the ext_iids of all Interfaces... More...
Protected Member Functions inherited from Service
| ~Service () override
| Standard Destructor. More...
int | outputLevel () const
| get the `Service's` output level More...
Protected Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
Gaudi::Details::PropertyBase * | property (const std::string &name) const
Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
void | updateMsgStreamOutputLevel (int level)
| Update the output level of the cached MsgStream. More...
Protected Attributes inherited from Service
Gaudi::StateMachine::State | m_state = Gaudi::StateMachine::OFFLINE
| Service state. More...
Gaudi::StateMachine::State | m_targetState = Gaudi::StateMachine::OFFLINE
| Service state. More...
Gaudi::Property< int > | m_outputLevel {this, "OutputLevel", MSG::NIL, "output level"}
Gaudi::Property< bool > | m_auditInit {this, "AuditServices", false, "[[deprecated]] unused"}
Gaudi::Property< bool > | m_auditorInitialize {this, "AuditInitialize", false, "trigger auditor on initialize()"}
Gaudi::Property< bool > | m_auditorStart {this, "AuditStart", false, "trigger auditor on start()"}
Gaudi::Property< bool > | m_auditorStop {this, "AuditStop", false, "trigger auditor on stop()"}
Gaudi::Property< bool > | m_auditorFinalize {this, "AuditFinalize", false, "trigger auditor on finalize()"}
Gaudi::Property< bool > | m_auditorReinitialize {this, "AuditReinitialize", false, "trigger auditor on reinitialize()"}
Gaudi::Property< bool > | m_auditorRestart {this, "AuditRestart", false, "trigger auditor on restart()"}
SmartIF< IAuditorSvc > | m_pAuditorSvc
| Auditor Service. More...

## Detailed Description

The AlgResourcePool is a concrete implementation of the IAlgResourcePool interface.

It either creates all instances upfront or lazily. Internal bookkeeping is done via hashes of the algo names.

Author
  Benedikt Hegner

Definition at line 31 of file AlgResourcePool.h.

## Member Typedef Documentation

typedef tbb::concurrent_bounded_queue<IAlgorithm*> AlgResourcePool::concurrentQueueIAlgPtr
| private

Definition at line 61 of file AlgResourcePool.h.

typedef std::list<SmartIF<IAlgorithm> > AlgResourcePool::ListAlg
| private

Definition at line 62 of file AlgResourcePool.h.

typedef boost::dynamic_bitset AlgResourcePool::state_type
| private

Definition at line 63 of file AlgResourcePool.h.

## Constructor & Destructor Documentation

AlgResourcePool::~AlgResourcePool | ( |  | ) |
| override

Definition at line 25 of file AlgResourcePool.cpp.

25 {
26
27 for (auto& algoId_algoQueue : m_algqueue_map){
28 auto* queue = algoId_algoQueue.second;
29 delete queue;
30 }
31
32 delete m_PRGraph;
33 }
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:68
AlgResourcePool::m_PRGraph
concurrency::PrecedenceRulesGraph * m_PRGraph
OMG yet another hack.
Definition: AlgResourcePool.h:101

## Member Function Documentation

StatusCode AlgResourcePool::acquireAlgorithm | ( | const std::string & | name,
|  | IAlgorithm *& | algo,
|  | bool | blocking = `false`
| ) |  |
| override

Acquire a certain algorithm using its name.

Definition at line 86 of file AlgResourcePool.cpp.

86 {
87
88 std::hash<std::string> hash_function;
89 size_t algo_id = hash_function(name);
90 auto itQueueIAlgPtr = m_algqueue_map.find(algo_id);
91
92 if (itQueueIAlgPtr == m_algqueue_map.end()) {
93 error() << "Algorithm " << name << " requested, but not recognised"
94 << endmsg;
95 algo = nullptr;
96 return StatusCode::FAILURE;
97 }
98
99 StatusCode sc;
100 if (blocking) {
101 itQueueIAlgPtr->second->pop(algo);
102 sc = StatusCode::SUCCESS;
103 } else {
104 sc = itQueueIAlgPtr->second->try_pop(algo);
105 }
106
107 // Note that reentrant algos are not consumed so we put them
108 // back immediately in the queue at the end of this function.
109 // Now we may still be called again in between and get this
110 // error. In such a case, the Scheduler will retry later.
111 // This is of course not optimal, but should only happen very
112 // seldom and thud won't affect the global efficiency
113 if(sc.isFailure())
114 DEBUG_MSG << "No instance of algorithm " << name << " could be retrieved in non-blocking mode" << endmsg;
115
116 // if (m_lazyCreation ) {
117 // TODO: fill the lazyCreation part
118 // }
119 if (sc.isSuccess()){
120 state_type requirements = m_resource_requirements[algo_id];
121 m_resource_mutex.lock();
122 if (requirements.is_subset_of(m_available_resources)) {
123 m_available_resources^=requirements;
124 } else {
125 sc = StatusCode::FAILURE;
126 error() << "Failure to allocate resources of algorithm " << name << endmsg;
127 // in case of not reentrant, push it back. Reentrant ones are pushed back
128 // in all cases further down
129 if (0 != algo->cardinality()) {
130 itQueueIAlgPtr->second->push(algo);
131 }
132 }
133 m_resource_mutex.unlock();
134 if (0 == algo->cardinality()) {
135 // push back reentrant algos immediately as it can be reused
136 itQueueIAlgPtr->second->push(algo);
137 }
138 }
139 return sc;
140 }
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::mutex::unlock
T unlock(T...args)
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:74
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:65
std::map::end
T end(T...args)
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:84
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:67
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:117
std::hash
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_resource_requirements
std::map< size_t, state_type > m_resource_requirements
Definition: AlgResourcePool.h:69
std::mutex::lock
T lock(T...args)
IAlgorithm::cardinality
virtual unsigned int cardinality() const =0
Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentra...
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:68
state_type
boost::dynamic_bitset state_type
Definition: EventSchedulingState.h:11
std::map::find
T find(T...args)
DEBUG_MSG
#define DEBUG_MSG
Definition: AlgResourcePool.cpp:20
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

StatusCode AlgResourcePool::acquireResource | ( | const std::string & | name | ) |
| override

Acquire a certain resource.

Definition at line 163 of file AlgResourcePool.cpp.

163 {
164 m_resource_mutex.lock();
165 m_available_resources[m_resource_indices[name]] = false;
166 m_resource_mutex.unlock();
167 return StatusCode::SUCCESS;
168 }
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::mutex::unlock
T unlock(T...args)
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:289
AlgResourcePool::m_resource_indices
std::map< std::string, unsigned int > m_resource_indices
Definition: AlgResourcePool.h:72
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:65
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:67
std::mutex::lock
T lock(T...args)

StatusCode AlgResourcePool::beginRun | ( |  | ) |
| override

Definition at line 414 of file AlgResourcePool.cpp.

414 {
415 auto algBeginRun = [&] (SmartIF<IAlgorithm>& algoSmartIF) -> StatusCode {
416 StatusCode sc = algoSmartIF->sysBeginRun();
417 if (!sc.isSuccess()) {
418 warning() << "beginRun() of algorithm " << algoSmartIF->name() << " failed" << endmsg;
419 return StatusCode::FAILURE;
420 }
421 return StatusCode::SUCCESS;
422 };
423 // Call the beginRun() method of all algorithms
424 for (auto& algoSmartIF : m_flatUniqueAlgList ) {
425 if (algBeginRun(algoSmartIF).isFailure())
426 return StatusCode::FAILURE;
427 }
428
429 return StatusCode::SUCCESS;
430 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:92
StatusCode::SUCCESS
Definition: StatusCode.h:30
SmartIF< IAlgorithm >
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:74
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:120
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

StatusCode AlgResourcePool::decodeTopAlgs | ( |  | ) |
| private

Decode the top alg list.

Definition at line 248 of file AlgResourcePool.cpp.

248 {
249
250 SmartIF<IAlgManager> algMan ( serviceLocator() );
251 if (!algMan.isValid()){
252 error() << "Algorithm manager could not be properly fetched." << endmsg;
253 return StatusCode::FAILURE;
254 }
255
256 // Useful lambda not to repeat ourselves --------------------------
257 auto createAlg = [&algMan,this] (const std::string& item_type,
258 const std::string& item_name,
259 IAlgorithm*& algo){
260 StatusCode createAlgSc = algMan->createAlgorithm(item_type,
261 item_name,
262 algo,
263 true,
264 false);
265 if (createAlgSc.isFailure())
266 this->warning() << "Algorithm " << item_type << "/" << item_name
267 << " could not be created." << endmsg;
268 };
269 // End of lambda --------------------------------------------------
270
271 StatusCode sc = StatusCode::SUCCESS;
272
273 // Fill the top alg list ----
274 const std::vector<std::string>& topAlgNames = m_topAlgNames.value();
275 for (auto& name : topAlgNames) {
276 IAlgorithm* algo(nullptr);
277
278 Gaudi::Utils::TypeNameString item(name);
279 const std::string& item_name = item.name();
280 const std::string& item_type = item.type();
281 SmartIF<IAlgorithm> algoSmartIF (algMan->algorithm(item_name,false));
282
283 if (!algoSmartIF.isValid()){
284 createAlg(item_type,item_name,algo);
285 algoSmartIF = algo;
286 }
287 // Init and start
288 algoSmartIF->sysInitialize();
289 m_topAlgList.push_back(algoSmartIF);
290 }
291 // Top Alg list filled ----
292
293 // start forming the graph of precedence rules by adding the head decision hub
294 m_PRGraph->addHeadNode("RootDecisionHub",true,false,true,true);
295
296 // Now we unroll it ----
297 for (auto& algoSmartIF : m_topAlgList) {
298 Algorithm* algorithm = dynamic_cast<Algorithm*> (algoSmartIF.get());
299 if (!algorithm) fatal() << "Conversion from IAlgorithm to Algorithm failed" << endmsg;
300 sc = flattenSequencer(algorithm, m_flatUniqueAlgList, "RootDecisionHub");
301 }
302 // stupid O(N^2) unique-ification..
303 for ( auto i = begin(m_flatUniqueAlgList); i!=end(m_flatUniqueAlgList); ++i ) {
304 auto n = next(i);
305 while ( n!=end(m_flatUniqueAlgList) ) {
306 if (*n==*i) n = m_flatUniqueAlgList.erase(n);
307 else ++n;
308 }
309 }
310 if (msgLevel(MSG::DEBUG)){
311 debug() << "List of algorithms is: " << endmsg;
312 for (auto& algo : m_flatUniqueAlgList)
313 debug() << " o " << algo->type() << "/" << algo->name() << " @ " << algo << endmsg;
314 }
315
316 // Unrolled ---
317
318 // Now let's manage the clones
319 unsigned int resource_counter(0);
320 std::hash<std::string> hash_function;
321 for (auto& ialgoSmartIF : m_flatUniqueAlgList) {
322
323 const std::string& item_name = ialgoSmartIF->name();
324
325 verbose() << "Treating resource management and clones of " << item_name << endmsg;
326
327 Algorithm* algo = dynamic_cast<Algorithm*> ( ialgoSmartIF.get() );
328 if (!algo) fatal() << "Conversion from IAlgorithm to Algorithm failed" << endmsg;
329 const std::string& item_type = algo->type();
330
331 size_t algo_id = hash_function(item_name);
332 concurrentQueueIAlgPtr* queue = new concurrentQueueIAlgPtr();
333 m_algqueue_map[algo_id] = queue;
334
335 // DP TODO Do it properly with SmartIFs, also in the queues
336 IAlgorithm* ialgo(ialgoSmartIF.get());
337
338 queue->push(ialgo);
339 m_algList.push_back(ialgo);
340 m_n_of_allowed_instances[algo_id] = ialgo->cardinality();
341 m_n_of_created_instances[algo_id] = 1;
342
343 state_type requirements(0);
344
345 for (auto& resource_name : ialgo->neededResources()){
346 auto ret = m_resource_indices.emplace(resource_name,resource_counter);
347 // insert successful means == wasn't known before. So increment counter
348 if (ret.second) ++resource_counter;
349 // Resize for every algo according to the found resources
350 requirements.resize(resource_counter);
351 // in any case the return value holds the proper product index
352 requirements[ret.first->second] = true;
353
354 }
355
356 m_resource_requirements[algo_id] = requirements;
357
358 // potentially create clones; if not lazy creation we have to do it now
359 if (!m_lazyCreation) {
360 for (unsigned int i =1, end =ialgo->cardinality();i<end; ++i){
361 debug() << "type/name to create clone of: " << item_type << "/"
362 << item_name << endmsg;
363 IAlgorithm* ialgoClone(nullptr);
364 createAlg(item_type,item_name,ialgoClone);
365 ialgoClone->setIndex(i);
366 if (ialgoClone->sysInitialize().isFailure()) {
367 error() << "unable to initialize Algorithm clone "
368 << ialgoClone->name() << endmsg;
369 sc = StatusCode::FAILURE;
370 // FIXME: should we delete this failed clone?
371 } else {
372 queue->push(ialgoClone);
373 m_n_of_created_instances[algo_id]+=1;
374 }
375 }
376 }
377
378 m_PRGraph->attachAlgorithmsToNodes<concurrentQueueIAlgPtr>(item_name,*queue);
379
380 }
381
382 // Now resize all the requirement bitsets to the same size
383 for (auto& kv : m_resource_requirements) {
384 kv.second.resize(resource_counter);
385 }
386
387 // Set all resources to be available
388 m_available_resources.resize(resource_counter);
389 m_available_resources.set();
390
391 return sc;
392 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:92
StatusCode::SUCCESS
Definition: StatusCode.h:30
SmartIF< IAlgManager >
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:289
concurrency::PrecedenceRulesGraph::attachAlgorithmsToNodes
void attachAlgorithmsToNodes(const std::string &algo_name, const T &container)
Attach pointers to real Algorithms (and their clones) to Algorithm nodes of the graph.
Definition: PrecedenceRulesGraph.h:307
StatusCode::FAILURE
Definition: StatusCode.h:29
AlgResourcePool::m_resource_indices
std::map< std::string, unsigned int > m_resource_indices
Definition: AlgResourcePool.h:72
CommonMessagingBase::verbose
MsgStream & verbose() const
shortcut for the method msgStream(MSG::VERBOSE)
Definition: CommonMessaging.h:129
MSG::DEBUG
Definition: IMessageSvc.h:18
concurrency::PrecedenceRulesGraph::addHeadNode
void addHeadNode(const std::string &headName, bool modeConcurrent, bool modePromptDecision, bool modeOR, bool allPass)
Add a node, which has no parents.
Definition: PrecedenceRulesGraph.cpp:718
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:84
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:67
begin
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:48
std::string
STL class.
GaudiPluginService.cpluginsvc.n
n
Definition: cpluginsvc.py:217
std::list::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:117
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:12
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:120
AlgResourcePool::concurrentQueueIAlgPtr
tbb::concurrent_bounded_queue< IAlgorithm * > concurrentQueueIAlgPtr
Definition: AlgResourcePool.h:61
std::hash
std::next
T next(T...args)
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_resource_requirements
std::map< size_t, state_type > m_resource_requirements
Definition: AlgResourcePool.h:69
std::list::erase
T erase(T...args)
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:50
AlgResourcePool::m_topAlgNames
Gaudi::Property< std::vector< std::string > > m_topAlgNames
Definition: AlgResourcePool.h:82
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:27
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:68
state_type
boost::dynamic_bitset state_type
Definition: EventSchedulingState.h:11
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:78
std::vector< std::string >
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:126
AlgResourcePool::flattenSequencer
StatusCode flattenSequencer(Algorithm *sequencer, ListAlg &alglist, const std::string &parentName, unsigned int recursionDepth=0)
Recursively flatten an algList.
Definition: AlgResourcePool.cpp:181
std::map::emplace
T emplace(T...args)
AlgResourcePool::m_n_of_created_instances
std::map< size_t, unsigned int > m_n_of_created_instances
Definition: AlgResourcePool.h:71
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:111
AlgResourcePool::m_PRGraph
concurrency::PrecedenceRulesGraph * m_PRGraph
OMG yet another hack.
Definition: AlgResourcePool.h:101
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:89
Algorithm::type
const std::string & type() const override
The type of the algorithm object.
Definition: Algorithm.h:165
CommonMessagingBase::msgLevel
MSG::Level msgLevel() const
get the output level from the embedded MsgStream
Definition: CommonMessaging.h:135
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:292
AlgResourcePool::m_n_of_allowed_instances
std::map< size_t, size_t > m_n_of_allowed_instances
Definition: AlgResourcePool.h:70
AlgResourcePool::m_algList
ListAlg m_algList
The list of all algorithms created withing the Pool which are not top.
Definition: AlgResourcePool.h:86
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244
AlgResourcePool::m_lazyCreation
Gaudi::Property< bool > m_lazyCreation
Definition: AlgResourcePool.h:81

StatusCode AlgResourcePool::endRun | ( |  | ) |
| override

Definition at line 434 of file AlgResourcePool.cpp.

434 {
435
436 auto algEndRun = [&] (SmartIF<IAlgorithm>& algoSmartIF) -> StatusCode {
437 StatusCode sc = algoSmartIF->sysEndRun();
438 if (!sc.isSuccess()) {
439 warning() << "endRun() of algorithm " << algoSmartIF->name() << " failed" << endmsg;
440 return StatusCode::FAILURE;
441 }
442 return StatusCode::SUCCESS;
443 };
444 // Call the beginRun() method of all top algorithms
445 for (auto& algoSmartIF : m_flatUniqueAlgList ) {
446 if (algEndRun(algoSmartIF).isFailure())
447 return StatusCode::FAILURE;
448 }
449 for (auto& algoSmartIF : m_topAlgList ) {
450 if (algEndRun(algoSmartIF).isFailure())
451 return StatusCode::FAILURE;
452 }
453 return StatusCode::SUCCESS;
454 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:92
StatusCode::SUCCESS
Definition: StatusCode.h:30
SmartIF< IAlgorithm >
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:74
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:120
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:89
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

StatusCode AlgResourcePool::flattenSequencer | ( | Algorithm * | sequencer,
|  | ListAlg & | alglist,
|  | const std::string & | parentName,
|  | unsigned int | recursionDepth = `0`
| ) |  |
| private

Recursively flatten an algList.

Definition at line 181 of file AlgResourcePool.cpp.

181 {
182
183 StatusCode sc = StatusCode::SUCCESS;
184
185 bool isGaudiSequencer(false);
186 bool isAthSequencer(false);
187
188 if (algo->hasProperty("Members")) {
189 if (algo->hasProperty("ShortCircuit"))
190 isGaudiSequencer = true;
191 else if (algo->hasProperty("StopOverride"))
192 isAthSequencer = true;
193 }
194
195 std::vector<Algorithm*>* subAlgorithms = algo->subAlgorithms();
196 if ( //we only want to add basic algorithms -> have no subAlgs
197 // and exclude the case of empty sequencers
198 (subAlgorithms->empty() && !(isGaudiSequencer || isAthSequencer)) ) {
199
200 DEBUG_MSG << std::string(recursionDepth, ' ') << algo->name()
201 << " is not a sequencer. Appending it" << endmsg;
202
203 alglist.emplace_back(algo);
204 m_PRGraph->addAlgorithmNode(algo, parentName, false, false).ignore();
205 return sc;
206 }
207
208 // Recursively unroll
209 ++recursionDepth;
210 DEBUG_MSG << std::string(recursionDepth, ' ') << algo->name() << " is a sequencer. Flattening it." << endmsg;
211 bool modeOR = false;
212 bool allPass = false;
213 bool isLazy = false;
214 bool isSequential = false;
215
216 if ( isGaudiSequencer ) {
217 modeOR = (algo->getProperty("ModeOR").toString() == "True")? true : false;
218 allPass = (algo->getProperty("IgnoreFilterPassed").toString() == "True")? true : false;
219 isLazy = (algo->getProperty("ShortCircuit").toString() == "True")? true : false;
220 if (allPass) isLazy = false; // standard GaudiSequencer behavior on all pass is to execute everything
221 isSequential = (algo->hasProperty("Sequential") &&
222 (algo->getProperty("Sequential").toString() == "True") );
223 } else if (isAthSequencer ) {
224 modeOR = (algo->getProperty("ModeOR").toString() == "True")? true : false;
225 allPass = (algo->getProperty("IgnoreFilterPassed").toString() == "True")? true : false;
226 isLazy = (algo->getProperty("StopOverride").toString() == "True")? false : true;
227 isSequential = (algo->hasProperty("Sequential") &&
228 (algo->getProperty("Sequential").toString() == "True") );
229 }
230 sc = m_PRGraph->addDecisionHubNode(algo, parentName, !isSequential, isLazy, modeOR, allPass);
231 if (sc.isFailure()) {
232 error() << "Failed to add DecisionHub " << algo->name() << " to graph of precedence rules" << endmsg;
233 return sc;
234 }
235
236 for (Algorithm* subalgo : *subAlgorithms ) {
237 sc = flattenSequencer(subalgo,alglist,algo->name(),recursionDepth);
238 if (sc.isFailure()) {
239 error() << "Algorithm " << subalgo->name() << " could not be flattened" << endmsg;
240 return sc;
241 }
242 }
243 return sc;
244 }
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::vector::empty
T empty(T...args)
concurrency::PrecedenceRulesGraph::addAlgorithmNode
StatusCode addAlgorithmNode(Algorithm *daughterAlgo, const std::string &parentName, bool inverted, bool allPass)
Add algorithm node.
Definition: PrecedenceRulesGraph.cpp:608
concurrency::PrecedenceRulesGraph::addDecisionHubNode
StatusCode addDecisionHubNode(Algorithm *daughterAlgo, const std::string &parentName, bool modeConcurrent, bool modePromptDecision, bool modeOR, bool allPass)
Add a node, which aggregates decisions of direct daughter nodes.
Definition: PrecedenceRulesGraph.cpp:681
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:84
std::string
STL class.
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:117
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:78
std::vector< Algorithm * >
AlgResourcePool::flattenSequencer
StatusCode flattenSequencer(Algorithm *sequencer, ListAlg &alglist, const std::string &parentName, unsigned int recursionDepth=0)
Recursively flatten an algList.
Definition: AlgResourcePool.cpp:181
DEBUG_MSG
#define DEBUG_MSG
Definition: AlgResourcePool.cpp:20
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:106
AlgResourcePool::m_PRGraph
concurrency::PrecedenceRulesGraph * m_PRGraph
OMG yet another hack.
Definition: AlgResourcePool.h:101
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

std::list< IAlgorithm * > AlgResourcePool::getFlatAlgList | ( |  | ) |
| override

Definition at line 396 of file AlgResourcePool.cpp.

396 {
397 m_flatUniqueAlgPtrList.clear();
398 for (auto algoSmartIF :m_flatUniqueAlgList )
399 m_flatUniqueAlgPtrList.push_back(const_cast<IAlgorithm*>(algoSmartIF.get()));
400 return m_flatUniqueAlgPtrList;
401 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:92
std::list::push_back
T push_back(T...args)
AlgResourcePool::m_flatUniqueAlgPtrList
std::list< IAlgorithm * > m_flatUniqueAlgPtrList
The flat list of algorithms w/o clones which is returned.
Definition: AlgResourcePool.h:95
std::list::clear
T clear(T...args)

virtual concurrency::PrecedenceRulesGraph* AlgResourcePool::getPRGraph | ( |  | ) | const
| inline virtual

Definition at line 58 of file AlgResourcePool.h.

58 { return m_PRGraph; }
AlgResourcePool::m_PRGraph
concurrency::PrecedenceRulesGraph * m_PRGraph
OMG yet another hack.
Definition: AlgResourcePool.h:101

std::list< IAlgorithm * > AlgResourcePool::getTopAlgList | ( |  | ) |
| override

Definition at line 405 of file AlgResourcePool.cpp.

405 {
406 m_topAlgPtrList.clear();
407 for (auto algoSmartIF :m_topAlgList )
408 m_topAlgPtrList.push_back(const_cast<IAlgorithm*>(algoSmartIF.get()));
409 return m_topAlgPtrList;
410 }
std::list::push_back
T push_back(T...args)
AlgResourcePool::m_topAlgPtrList
std::list< IAlgorithm * > m_topAlgPtrList
The top list of algorithms.
Definition: AlgResourcePool.h:98
std::list::clear
T clear(T...args)
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:89

StatusCode AlgResourcePool::initialize | ( |  | ) |
| override

Definition at line 38 of file AlgResourcePool.cpp.

38 {
39
40 StatusCode sc(Service::initialize());
41 if (!sc.isSuccess())
42 warning () << "Base class could not be started" << endmsg;
43
44 // Try to recover the topAlgList from the ApplicationManager for backward-compatibility
45 if (m_topAlgNames.value().empty()){
46 info() << "TopAlg list empty. Recovering the one of Application Manager" << endmsg;
47 const Gaudi::Utils::TypeNameString appMgrName("ApplicationMgr/ApplicationMgr");
48 SmartIF<IProperty> appMgrProps (serviceLocator()->service(appMgrName));
49 m_topAlgNames.assign(appMgrProps->getProperty("TopAlg"));
50 }
51
52 // Prepare empty graph of precedence rules
53 const std::string& name = "PrecedenceRulesGraph";
54 SmartIF<ISvcLocator> svc = serviceLocator();
55 m_PRGraph = new concurrency::PrecedenceRulesGraph(name, svc);
56
57 sc = decodeTopAlgs();
58 if (sc.isFailure())
59 warning() << "Algorithms could not be properly decoded." << endmsg;
60
61 // let's assume all resources are there
62 m_available_resources.set();
63 return StatusCode::SUCCESS;
64 }
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:64
StatusCode::SUCCESS
Definition: StatusCode.h:30
SmartIF< IProperty >
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:289
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:123
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:67
std::string
STL class.
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:12
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:120
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_topAlgNames
Gaudi::Property< std::vector< std::string > > m_topAlgNames
Definition: AlgResourcePool.h:82
concurrency::PrecedenceRulesGraph
Definition: PrecedenceRulesGraph.h:280
AlgResourcePool::decodeTopAlgs
StatusCode decodeTopAlgs()
Decode the top alg list.
Definition: AlgResourcePool.cpp:248
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
AlgResourcePool::m_PRGraph
concurrency::PrecedenceRulesGraph * m_PRGraph
OMG yet another hack.
Definition: AlgResourcePool.h:101
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:292
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

StatusCode AlgResourcePool::releaseAlgorithm | ( | const std::string & | name,
|  | IAlgorithm *& | algo
| ) |  |
| override

Release a certain algorithm.

Definition at line 144 of file AlgResourcePool.cpp.

144 {
145
146 std::hash<std::string> hash_function;
147 size_t algo_id = hash_function(name);
148
149 // release resources used by the algorithm
150 m_resource_mutex.lock();
151 m_available_resources|= m_resource_requirements[algo_id];
152 m_resource_mutex.unlock();
153
154 // release algorithm itself if not reentrant
155 if (0 != algo->cardinality()) {
156 m_algqueue_map[algo_id]->push(algo);
157 }
158 return StatusCode::SUCCESS;
159 }
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::mutex::unlock
T unlock(T...args)
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:65
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:67
std::hash
AlgResourcePool::m_resource_requirements
std::map< size_t, state_type > m_resource_requirements
Definition: AlgResourcePool.h:69
std::mutex::lock
T lock(T...args)
IAlgorithm::cardinality
virtual unsigned int cardinality() const =0
Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentra...
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:68

StatusCode AlgResourcePool::releaseResource | ( | const std::string & | name | ) |
| override

Release a certrain resource.

Definition at line 172 of file AlgResourcePool.cpp.

172 {
173 m_resource_mutex.lock();
174 m_available_resources[m_resource_indices[name]] = true;
175 m_resource_mutex.unlock();
176 return StatusCode::SUCCESS;
177 }
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::mutex::unlock
T unlock(T...args)
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:289
AlgResourcePool::m_resource_indices
std::map< std::string, unsigned int > m_resource_indices
Definition: AlgResourcePool.h:72
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:65
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:67
std::mutex::lock
T lock(T...args)

StatusCode AlgResourcePool::start | ( |  | ) |
| override

Definition at line 68 of file AlgResourcePool.cpp.

68 {
69
70 StatusCode startSc = Service::start();
71 if ( ! startSc.isSuccess() ) return startSc;
72
73 // sys-Start the algos
74 for (auto& ialgo : m_algList){
75 startSc = ialgo->sysStart();
76 if (startSc.isFailure()){
77 error() << "Unable to start Algorithm: " << ialgo->name() << endmsg;
78 return startSc;
79 }
80 }
81 return StatusCode::SUCCESS;
82 }
StatusCode::SUCCESS
Definition: StatusCode.h:30
Service::start
StatusCode start() override
Definition: Service.cpp:137
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:74
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:84
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:117
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_algList
ListAlg m_algList
The list of all algorithms created withing the Pool which are not top.
Definition: AlgResourcePool.h:86
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

StatusCode AlgResourcePool::stop | ( |  | ) |
| override

Definition at line 458 of file AlgResourcePool.cpp.

458 {
459
460 StatusCode stopSc = Service::stop();
461 if ( ! stopSc.isSuccess() ) return stopSc;
462
463 // sys-Stop the algos
464 for (auto& ialgo : m_algList){
465 stopSc = ialgo->sysStop();
466 if (stopSc.isFailure()){
467 error() << "Unable to stop Algorithm: " << ialgo->name() << endmsg;
468 return stopSc;
469 }
470 }
471 return StatusCode::SUCCESS;
472 }
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:74
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:84
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:117
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Service::stop
StatusCode stop() override
Definition: Service.cpp:130
AlgResourcePool::m_algList
ListAlg m_algList
The list of all algorithms created withing the Pool which are not top.
Definition: AlgResourcePool.h:86
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

## Member Data Documentation

ListAlg AlgResourcePool::m_algList
| private

The list of all algorithms created withing the Pool which are not top.

Definition at line 86 of file AlgResourcePool.h.

std::map<size_t, concurrentQueueIAlgPtr*> AlgResourcePool::m_algqueue_map
| private

Definition at line 68 of file AlgResourcePool.h.

state_type AlgResourcePool::m_available_resources {0}
| private

Definition at line 67 of file AlgResourcePool.h.

ListAlg AlgResourcePool::m_flatUniqueAlgList
| private

The flat list of algorithms w/o clones.

Definition at line 92 of file AlgResourcePool.h.

std::list<IAlgorithm*> AlgResourcePool::m_flatUniqueAlgPtrList
| private

The flat list of algorithms w/o clones which is returned.

Definition at line 95 of file AlgResourcePool.h.

Gaudi::Property<bool> AlgResourcePool::m_lazyCreation {this, "CreateLazily", false, ""}
| private

Definition at line 81 of file AlgResourcePool.h.

std::map<size_t, size_t> AlgResourcePool::m_n_of_allowed_instances
| private

Definition at line 70 of file AlgResourcePool.h.

std::map<size_t, unsigned int> AlgResourcePool::m_n_of_created_instances
| private

Definition at line 71 of file AlgResourcePool.h.

concurrency::PrecedenceRulesGraph* AlgResourcePool::m_PRGraph = nullptr
| private

OMG yet another hack.

Definition at line 101 of file AlgResourcePool.h.

std::map<std::string, unsigned int> AlgResourcePool::m_resource_indices
| private

Definition at line 72 of file AlgResourcePool.h.

std::mutex AlgResourcePool::m_resource_mutex
| private

Definition at line 65 of file AlgResourcePool.h.

std::map<size_t, state_type> AlgResourcePool::m_resource_requirements
| private

Definition at line 69 of file AlgResourcePool.h.

ListAlg AlgResourcePool::m_topAlgList
| private

The list of top algorithms.

Definition at line 89 of file AlgResourcePool.h.

Gaudi::Property<std::vector<std::string> > AlgResourcePool::m_topAlgNames
| private

Initial value:
{
this, "TopAlg", {}, "names of the algorithms to be passed to the algorithm manager"}

Definition at line 82 of file AlgResourcePool.h.

std::list<IAlgorithm*> AlgResourcePool::m_topAlgPtrList
| private

The top list of algorithms.

Definition at line 98 of file AlgResourcePool.h.

The documentation for this class was generated from the following files:

- GaudiHive/src/AlgResourcePool.h
- GaudiHive/src/AlgResourcePool.cpp