| The Gaudi Framework v27r1

- 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 (const std::string &name, ISvcLocator *svc)
| ~AlgResourcePool ()
virtual StatusCode | start ()
virtual StatusCode | initialize ()
virtual StatusCode | acquireAlgorithm (const std::string &name, IAlgorithm *&algo, bool blocking=false)
| Acquire a certain algorithm using its name. More...
virtual StatusCode | releaseAlgorithm (const std::string &name, IAlgorithm *&algo)
| Release a certain algorithm. More...
virtual StatusCode | acquireResource (const std::string &name)
| Acquire a certain resource. More...
virtual StatusCode | releaseResource (const std::string &name)
| Release a certrain resource. More...
virtual std::list< IAlgorithm * > | getFlatAlgList ()
virtual std::list< IAlgorithm * > | getTopAlgList ()
virtual StatusCode | beginRun ()
virtual StatusCode | endRun ()
virtual StatusCode | stop ()
virtual concurrency::ExecutionFlowGraph * | getExecutionFlowGraph () 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...
StatusCode | setProperty (const Property &p) override
StatusCode | setProperty (const std::string &s) override
StatusCode | setProperty (const std::string &n, const std::string &v) override
StatusCode | getProperty (Property *p) const override
const Property & | getProperty (const std::string &name) const override
StatusCode | getProperty (const std::string &n, std::string &v) const override
const std::vector< Property * > & | getProperties () const override
bool | hasProperty (const std::string &name) const override
template<class TYPE >
StatusCode | setProperty (const std::string &name, const TYPE &value)
| set the property form the value 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 >
Property * | declareProperty (const std::string &name, T &property, const std::string &doc="none") const
| Declare the named property. More...
Property * | declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="") const
| Declare remote named properties. 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 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
bool | m_lazyCreation
state_type | m_available_resources
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
StringArrayProperty | m_topAlgNames
| The names of the algorithms to be passed to the algorithm manager. More...
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::ExecutionFlowGraph * | m_EFGraph
| 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 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 CommonMessaging< implements< IService, IProperty, IStateful > >
void | updateMsgStreamOutputLevel (int level)
| Update the output level of the cached MsgStream. More...
Protected Attributes inherited from Service
IntegerProperty | m_outputLevel = MSG::NIL
| Service output level. More...
Gaudi::StateMachine::State | m_state = Gaudi::StateMachine::OFFLINE
| Service state. More...
Gaudi::StateMachine::State | m_targetState = Gaudi::StateMachine::OFFLINE
| Service state. 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 34 of file AlgResourcePool.h.

## Member Typedef Documentation

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

Definition at line 64 of file AlgResourcePool.h.

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

Definition at line 65 of file AlgResourcePool.h.

typedef boost::dynamic_bitset AlgResourcePool::state_type
| private

Definition at line 66 of file AlgResourcePool.h.

## Constructor & Destructor Documentation

AlgResourcePool::AlgResourcePool | ( | const std::string & | name,
|  | ISvcLocator * | svc
| ) |  |

Definition at line 19 of file AlgResourcePool.cpp.

19 :
20 base_class(name,svc), m_available_resources(0), m_EFGraph(0)
21 {
22 declareProperty("CreateLazily", m_lazyCreation = false );
23 declareProperty("TopAlg", m_topAlgNames );
24 }
AlgResourcePool::m_topAlgNames
StringArrayProperty m_topAlgNames
The names of the algorithms to be passed to the algorithm manager.
Definition: AlgResourcePool.h:84
extends< Service, IAlgResourcePool >::base_class
extends base_class
Typedef to this class.
Definition: extends.h:14
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:70
AlgResourcePool::m_EFGraph
concurrency::ExecutionFlowGraph * m_EFGraph
OMG yet another hack.
Definition: AlgResourcePool.h:102
AlgResourcePool::m_lazyCreation
bool m_lazyCreation
Definition: AlgResourcePool.h:69
Service::declareProperty
Property * declareProperty(const std::string &name, T &property, const std::string &doc="none") const
Declare the named property.
Definition: Service.h:215

AlgResourcePool::~AlgResourcePool | ( |  | ) |

Definition at line 29 of file AlgResourcePool.cpp.

29 {
30
31 for (auto& algoId_algoQueue : m_algqueue_map){
32 auto* queue = algoId_algoQueue.second;
33 delete queue;
34 }
35
36 delete m_EFGraph;
37 }
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:71
AlgResourcePool::m_EFGraph
concurrency::ExecutionFlowGraph * m_EFGraph
OMG yet another hack.
Definition: AlgResourcePool.h:102

## Member Function Documentation

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

Acquire a certain algorithm using its name.

Definition at line 90 of file AlgResourcePool.cpp.

90 {
91
92 std::hash<std::string> hash_function;
93 size_t algo_id = hash_function(name);
94 auto itQueueIAlgPtr = m_algqueue_map.find(algo_id);
95
96 if (itQueueIAlgPtr == m_algqueue_map.end()) {
97 error() << "Algorithm " << name << " requested, but not recognised"
98 << endmsg;
99 algo = nullptr;
100 return StatusCode::FAILURE;
101 }
102
103 StatusCode sc;
104 if (blocking) {
105 itQueueIAlgPtr->second->pop(algo);
106 sc = StatusCode::SUCCESS;
107 } else {
108 sc = itQueueIAlgPtr->second->try_pop(algo);
109 }
110
111 if(sc.isFailure())
112 if (msgLevel(MSG::DEBUG))
113 debug() << "No instance of algorithm " << name << " could be retrieved in non-blocking mode" << endmsg;
114
115 // if (m_lazyCreation ) {
116 // TODO: fill the lazyCreation part
117 //}
118 if (sc.isSuccess()){
119 algo->resetExecuted();
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 itQueueIAlgPtr->second->push(algo);
128 }
129 m_resource_mutex.unlock();
130 }
131 return sc;
132 }
std::mutex::unlock
T unlock(T...args)
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:71
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
MSG::DEBUG
Definition: IMessageSvc.h:18
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:68
std::map::end
T end(T...args)
IAlgorithm::resetExecuted
virtual void resetExecuted()=0
Reset the Algorithm executed state for the current event.
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:70
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
StatusCode::FAILURE
Definition: StatusCode.h:29
std::hash
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
std::mutex::lock
T lock(T...args)
state_type
boost::dynamic_bitset state_type
Definition: EventSchedulingState.h:11
std::map::find
T find(T...args)
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:127
AlgResourcePool::m_resource_requirements
std::map< size_t, state_type > m_resource_requirements
Definition: AlgResourcePool.h:72
CommonMessagingBase::msgLevel
MSG::Level msgLevel() const
get the output level from the embedded MsgStream
Definition: CommonMessaging.h:136
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 | ) |
| virtual

Acquire a certain resource.

Definition at line 153 of file AlgResourcePool.cpp.

153 {
154 m_resource_mutex.lock();
155 m_available_resources[m_resource_indices[name]] = false;
156 m_resource_mutex.unlock();
157 return StatusCode::SUCCESS;
158 }
std::mutex::unlock
T unlock(T...args)
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:68
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:70
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:319
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::mutex::lock
T lock(T...args)
AlgResourcePool::m_resource_indices
std::map< std::string, unsigned int > m_resource_indices
Definition: AlgResourcePool.h:75

StatusCode AlgResourcePool::beginRun | ( |  | ) |
| virtual

Definition at line 381 of file AlgResourcePool.cpp.

381 {
382 auto algBeginRun = [&] (SmartIF<IAlgorithm>& algoSmartIF) -> StatusCode {
383 StatusCode sc = algoSmartIF->sysBeginRun();
384 if (!sc.isSuccess()) {
385 warning() << "beginRun() of algorithm " << algoSmartIF->name() << " failed" << endmsg;
386 return StatusCode::FAILURE;
387 }
388 return StatusCode::SUCCESS;
389 };
390 // Call the beginRun() method of all algorithms
391 for (auto& algoSmartIF : m_flatUniqueAlgList ) {
392 if (algBeginRun(algoSmartIF).isFailure())
393 return StatusCode::FAILURE;
394 }
395
396 return StatusCode::SUCCESS;
397 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:93
SmartIF< IAlgorithm >
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
merge_files.sc
int sc
Definition: merge_files.py:167
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:121
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
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 221 of file AlgResourcePool.cpp.

221 {
222
223 SmartIF<IAlgManager> algMan ( serviceLocator() );
224 if (!algMan.isValid()){
225 error() << "Algorithm manager could not be properly fetched." << endmsg;
226 return StatusCode::FAILURE;
227 }
228
229 // Useful lambda not to repeat ourselves --------------------------
230 auto createAlg = [&algMan,this] (const std::string& item_type,
231 const std::string& item_name,
232 IAlgorithm*& algo){
233 StatusCode createAlgSc = algMan->createAlgorithm(item_type,
234 item_name,
235 algo,
236 true,
237 false);
238 if (createAlgSc.isFailure())
239 this->warning() << "Algorithm " << item_type << "/" << item_name
240 << " could not be created." << endmsg;
241 };
242 // End of lambda --------------------------------------------------
243
244 StatusCode sc = StatusCode::SUCCESS;
245
246 // Fill the top alg list ----
247 const std::vector<std::string>& topAlgNames = m_topAlgNames.value();
248 for (auto& name : topAlgNames) {
249 IAlgorithm* algo(nullptr);
250
251 Gaudi::Utils::TypeNameString item(name);
252 const std::string& item_name = item.name();
253 const std::string& item_type = item.type();
254 SmartIF<IAlgorithm> algoSmartIF (algMan->algorithm(item_name,false));
255
256 if (!algoSmartIF.isValid()){
257 createAlg(item_type,item_name,algo);
258 algoSmartIF = algo;
259 }
260 // Init and start
261 algoSmartIF->sysInitialize();
262 m_topAlgList.push_back(algoSmartIF);
263 }
264 // Top Alg list filled ----
265
266 // start forming the control flow graph by adding the head node
267 m_EFGraph->addHeadNode("EVENT LOOP",true,true,false);
268
269 // Now we unroll it ----
270 for (auto& algoSmartIF : m_topAlgList){
271 Algorithm* algorithm = dynamic_cast<Algorithm*> (algoSmartIF.get());
272 if (!algorithm) fatal() << "Conversion from IAlgorithm to Algorithm failed" << endmsg;
273 sc = flattenSequencer(algorithm, m_flatUniqueAlgList, "EVENT LOOP");
274 }
275 if (msgLevel(MSG::DEBUG)){
276 debug() << "List of algorithms is: " << endmsg;
277 for (auto& algo : m_flatUniqueAlgList)
278 debug() << " o " << algo->type() << "/" << algo->name() << " @ " << algo << endmsg;
279 }
280
281 // Unrolled ---
282
283 // Now let's manage the clones
284 unsigned int resource_counter(0);
285 std::hash<std::string> hash_function;
286 for (auto& ialgoSmartIF : m_flatUniqueAlgList) {
287
288 const std::string& item_name = ialgoSmartIF->name();
289
290 verbose() << "Treating resource management and clones of " << item_name << endmsg;
291
292 Algorithm* algo = dynamic_cast<Algorithm*> ( ialgoSmartIF.get() );
293 if (!algo) fatal() << "Conversion from IAlgorithm to Algorithm failed" << endmsg;
294 const std::string& item_type = algo->type();
295
296 size_t algo_id = hash_function(item_name);
297 concurrentQueueIAlgPtr* queue = new concurrentQueueIAlgPtr();
298 m_algqueue_map[algo_id] = queue;
299
300 // DP TODO Do it properly with SmartIFs, also in the queues
301 IAlgorithm* ialgo(ialgoSmartIF.get());
302
303 queue->push(ialgo);
304 m_algList.push_back(ialgo);
305 m_n_of_allowed_instances[algo_id] = ialgo->cardinality();
306 m_n_of_created_instances[algo_id] = 1;
307
308 state_type requirements(0);
309
310 for (auto& resource_name : ialgo->neededResources()){
311 auto ret = m_resource_indices.insert(std::pair<std::string, unsigned int>(resource_name,resource_counter));
312 // insert successful means == wasn't known before. So increment counter
313 if (ret.second==true) {
314 ++resource_counter;
315 }
316 // Resize for every algo according to the found resources
317 requirements.resize(resource_counter);
318 // in any case the return value holds the proper product index
319 requirements[ret.first->second] = true;
320
321 }
322
323 m_resource_requirements[algo_id] = requirements;
324
325 // potentially create clones; if not lazy creation we have to do it now
326 if (!m_lazyCreation) {
327 for (unsigned int i =1, end =ialgo->cardinality();i<end; ++i){
328 debug() << "type/name to create clone of: " << item_type << "/"
329 << item_name << endmsg;
330 IAlgorithm* ialgoClone(nullptr);
331 createAlg(item_type,item_name,ialgoClone);
332 ialgoClone->setIndex(i);
333 if (ialgoClone->sysInitialize().isFailure()) {
334 error() << "unable to initialize Algorithm clone "
335 << ialgoClone->name() << endmsg;
336 sc = StatusCode::FAILURE;
337 // FIXME: should we delete this failed clone?
338 } else {
339 queue->push(ialgoClone);
340 m_n_of_created_instances[algo_id]+=1;
341 }
342 }
343 }
344
345 m_EFGraph->attachAlgorithmsToNodes<concurrentQueueIAlgPtr>(item_name,*queue);
346
347 }
348
349 // Now resize all the requirement bitsets to the same size
350 for (auto& kv : m_resource_requirements) {
351 kv.second.resize(resource_counter);
352 }
353
354 // Set all resources to be available
355 m_available_resources.resize(resource_counter);
356 m_available_resources.set();
357
358 return sc;
359 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:93
AlgResourcePool::m_topAlgNames
StringArrayProperty m_topAlgNames
The names of the algorithms to be passed to the algorithm manager.
Definition: AlgResourcePool.h:84
SmartIF< IAlgManager >
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:324
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:71
CommonMessagingBase::verbose
MsgStream & verbose() const
shortcut for the method msgStream(MSG::VERBOSE)
Definition: CommonMessaging.h:130
MSG::DEBUG
Definition: IMessageSvc.h:18
Algorithm::type
const std::string & type() const override
The type of the algorithm object.
Definition: Algorithm.h:168
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:70
std::string
STL class.
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:319
std::list::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:9
AlgResourcePool::m_n_of_allowed_instances
std::map< size_t, size_t > m_n_of_allowed_instances
Definition: AlgResourcePool.h:73
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:121
StatusCode::FAILURE
Definition: StatusCode.h:29
AlgResourcePool::concurrentQueueIAlgPtr
tbb::concurrent_bounded_queue< IAlgorithm * > concurrentQueueIAlgPtr
Definition: AlgResourcePool.h:64
std::hash
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_EFGraph
concurrency::ExecutionFlowGraph * m_EFGraph
OMG yet another hack.
Definition: AlgResourcePool.h:102
AlgResourcePool::m_lazyCreation
bool m_lazyCreation
Definition: AlgResourcePool.h:69
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:47
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:25
PropertyWithValue::value
const TYPE & value() const
explicit conversion
Definition: Property.h:341
std::pair
state_type
boost::dynamic_bitset state_type
Definition: EventSchedulingState.h:11
std::map::insert
T insert(T...args)
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:74
std::vector< std::string >
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:127
AlgResourcePool::flattenSequencer
StatusCode flattenSequencer(Algorithm *sequencer, ListAlg &alglist, const std::string &parentName, unsigned int recursionDepth=0)
Recursively flatten an algList.
Definition: AlgResourcePool.cpp:171
AlgResourcePool::m_resource_requirements
std::map< size_t, state_type > m_resource_requirements
Definition: AlgResourcePool.h:72
ana.item
tuple item
print s1,s2
Definition: ana.py:146
concurrency::ExecutionFlowGraph::addHeadNode
void addHeadNode(const std::string &headName, bool modeOR, bool allPass, bool isLazy)
Add a node, which has no parents.
Definition: ExecutionFlowGraph.cpp:679
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:112
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:90
AlgResourcePool::m_resource_indices
std::map< std::string, unsigned int > m_resource_indices
Definition: AlgResourcePool.h:75
CommonMessagingBase::msgLevel
MSG::Level msgLevel() const
get the output level from the embedded MsgStream
Definition: CommonMessaging.h:136
concurrency::ExecutionFlowGraph::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: ExecutionFlowGraph.h:298
ana.i
list i
Definition: ana.py:128
AlgResourcePool::m_n_of_created_instances
std::map< size_t, unsigned int > m_n_of_created_instances
Definition: AlgResourcePool.h:74
AlgResourcePool::m_algList
ListAlg m_algList
The list of all algorithms created withing the Pool which are not top.
Definition: AlgResourcePool.h:87
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

StatusCode AlgResourcePool::endRun | ( |  | ) |
| virtual

Definition at line 401 of file AlgResourcePool.cpp.

401 {
402
403 auto algEndRun = [&] (SmartIF<IAlgorithm>& algoSmartIF) -> StatusCode {
404 StatusCode sc = algoSmartIF->sysEndRun();
405 if (!sc.isSuccess()) {
406 warning() << "endRun() of algorithm " << algoSmartIF->name() << " failed" << endmsg;
407 return StatusCode::FAILURE;
408 }
409 return StatusCode::SUCCESS;
410 };
411 // Call the beginRun() method of all top algorithms
412 for (auto& algoSmartIF : m_flatUniqueAlgList ) {
413 if (algEndRun(algoSmartIF).isFailure())
414 return StatusCode::FAILURE;
415 }
416 for (auto& algoSmartIF : m_topAlgList ) {
417 if (algEndRun(algoSmartIF).isFailure())
418 return StatusCode::FAILURE;
419 }
420 return StatusCode::SUCCESS;
421 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:93
SmartIF< IAlgorithm >
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
merge_files.sc
int sc
Definition: merge_files.py:167
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:121
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
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:90
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 171 of file AlgResourcePool.cpp.

171 {
172
173 StatusCode sc = StatusCode::SUCCESS;
174
175 std::vector<Algorithm*>* subAlgorithms = algo->subAlgorithms();
176 if ( //we only want to add basic algorithms -> have no subAlgs
177 // and exclude the case of empty GaudiSequencers
178 (subAlgorithms->empty() and not (algo->type() == "GaudiSequencer"))
179 // we want to add non-empty GaudiAtomicSequencers
180 or (algo->type() == "GaudiAtomicSequencer" and not subAlgorithms->empty())){
181
182 debug() << std::string(recursionDepth, ' ') << algo->name() << " is " <<
183 (algo->type() != "GaudiAtomicSequencer" ? "not a sequencer" : "an atomic sequencer")
184 << ". Appending it" << endmsg;
185
186 alglist.emplace_back(algo);
187 m_EFGraph->addAlgorithmNode(algo,parentName,false,false);
188 return sc;
189 }
190
191 // Recursively unroll
192 ++recursionDepth;
193 debug() << std::string(recursionDepth, ' ') << algo->name() << " is a sequencer. Flattening it." << endmsg;
194 bool modeOR = false;
195 bool allPass = false;
196 bool isLazy = false;
197 if ("GaudiSequencer" == algo->type()) {
198 modeOR = (algo->getProperty("ModeOR").toString() == "True")? true : false;
199 allPass = (algo->getProperty("IgnoreFilterPassed").toString() == "True")? true : false;
200 isLazy = (algo->getProperty("ShortCircuit").toString() == "True")? true : false;
201 if (allPass) isLazy = false; // standard GaudiSequencer behavior on all pass is to execute everything
202 }
203 sc = m_EFGraph->addDecisionHubNode(algo,parentName,modeOR,allPass,isLazy);
204 if (sc.isFailure()) {
205 error() << "Failed to add DecisionHub " << algo->name() << " to execution flow graph" << endmsg;
206 return sc;
207 }
208
209 for (Algorithm* subalgo : *subAlgorithms ) {
210 sc = flattenSequencer(subalgo,alglist,algo->name(),recursionDepth);
211 if (sc.isFailure()) {
212 error() << "Algorithm " << subalgo->name() << " could not be flattened" << endmsg;
213 return sc;
214 }
215 }
216 return sc;
217 }
std::vector::empty
T empty(T...args)
concurrency::ExecutionFlowGraph::addDecisionHubNode
StatusCode addDecisionHubNode(Algorithm *daughterAlgo, const std::string &parentName, bool modeOR, bool allPass, bool isLazy)
Add a node, which aggregates decisions of direct daughter nodes.
Definition: ExecutionFlowGraph.cpp:647
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
std::string
STL class.
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_EFGraph
concurrency::ExecutionFlowGraph * m_EFGraph
OMG yet another hack.
Definition: AlgResourcePool.h:102
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:74
std::vector< Algorithm * >
concurrency::ExecutionFlowGraph::addAlgorithmNode
StatusCode addAlgorithmNode(Algorithm *daughterAlgo, const std::string &parentName, bool inverted, bool allPass)
Add algorithm node.
Definition: ExecutionFlowGraph.cpp:581
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:127
AlgResourcePool::flattenSequencer
StatusCode flattenSequencer(Algorithm *sequencer, ListAlg &alglist, const std::string &parentName, unsigned int recursionDepth=0)
Recursively flatten an algList.
Definition: AlgResourcePool.cpp:171
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

virtual concurrency::ExecutionFlowGraph* AlgResourcePool::getExecutionFlowGraph | ( |  | ) | const
| inline virtual

Definition at line 61 of file AlgResourcePool.h.

61 {return m_EFGraph;}
AlgResourcePool::m_EFGraph
concurrency::ExecutionFlowGraph * m_EFGraph
OMG yet another hack.
Definition: AlgResourcePool.h:102

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

Definition at line 363 of file AlgResourcePool.cpp.

363 {
364 m_flatUniqueAlgPtrList.clear();
365 for (auto algoSmartIF :m_flatUniqueAlgList )
366 m_flatUniqueAlgPtrList.push_back(const_cast<IAlgorithm*>(algoSmartIF.get()));
367 return m_flatUniqueAlgPtrList;
368 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:93
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:96
std::list::clear
T clear(T...args)

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

Definition at line 372 of file AlgResourcePool.cpp.

372 {
373 m_topAlgPtrList.clear();
374 for (auto algoSmartIF :m_topAlgList )
375 m_topAlgPtrList.push_back(const_cast<IAlgorithm*>(algoSmartIF.get()));
376 return m_topAlgPtrList;
377 }
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:99
std::list::clear
T clear(T...args)
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:90

StatusCode AlgResourcePool::initialize | ( |  | ) |
| virtual

Definition at line 42 of file AlgResourcePool.cpp.

42 {
43
44 StatusCode sc(Service::initialize());
45 if (!sc.isSuccess())
46 warning () << "Base class could not be started" << endmsg;
47
48 // Try to recover the topAlgList from the ApplicationManager for backward-compatibility
49 if (m_topAlgNames.value().empty()){
50 info() << "TopAlg list empty. Recovering the one of Application Manager" << endmsg;
51 const Gaudi::Utils::TypeNameString appMgrName("ApplicationMgr/ApplicationMgr");
52 SmartIF<IProperty> appMgrProps (serviceLocator()->service(appMgrName));
53 m_topAlgNames.assign(appMgrProps->getProperty("TopAlg"));
54 }
55
56 // XXX: Prepare empty Control Flow graph
57 const std::string& name = "ExecutionFlowGraph";
58 SmartIF<ISvcLocator> svc = serviceLocator();
59 m_EFGraph = new concurrency::ExecutionFlowGraph(name, svc);
60
61 sc = decodeTopAlgs();
62 if (sc.isFailure())
63 warning() << "Algorithms could not be properly decoded." << endmsg;
64
65 // let's assume all resources are there
66 m_available_resources.set();
67 return StatusCode::SUCCESS;
68 }
AlgResourcePool::m_topAlgNames
StringArrayProperty m_topAlgNames
The names of the algorithms to be passed to the algorithm manager.
Definition: AlgResourcePool.h:84
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:68
SmartIF< IProperty >
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:324
std::vector::empty
T empty(T...args)
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:124
merge_files.sc
int sc
Definition: merge_files.py:167
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:70
std::string
STL class.
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:319
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:9
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:121
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_EFGraph
concurrency::ExecutionFlowGraph * m_EFGraph
OMG yet another hack.
Definition: AlgResourcePool.h:102
PropertyWithValue::value
const TYPE & value() const
explicit conversion
Definition: Property.h:341
PropertyWithValue::assign
bool assign(const Property &source) override
get the value from another property
Definition: Property.h:269
AlgResourcePool::decodeTopAlgs
StatusCode decodeTopAlgs()
Decode the top alg list.
Definition: AlgResourcePool.cpp:221
concurrency::ExecutionFlowGraph
Definition: ExecutionFlowGraph.h:271
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't already exist.
Definition: Service.h:144
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
| ) |  |
| virtual

Release a certain algorithm.

Definition at line 136 of file AlgResourcePool.cpp.

136 {
137
138 std::hash<std::string> hash_function;
139 size_t algo_id = hash_function(name);
140
141 // release resources used by the algorithm
142 m_resource_mutex.lock();
143 m_available_resources|= m_resource_requirements[algo_id];
144 m_resource_mutex.unlock();
145
146 //release algorithm itself
147 m_algqueue_map[algo_id]->push(algo);
148 return StatusCode::SUCCESS;
149 }
std::mutex::unlock
T unlock(T...args)
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:71
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:68
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:70
std::hash
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::mutex::lock
T lock(T...args)
AlgResourcePool::m_resource_requirements
std::map< size_t, state_type > m_resource_requirements
Definition: AlgResourcePool.h:72

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

Release a certrain resource.

Definition at line 162 of file AlgResourcePool.cpp.

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

StatusCode AlgResourcePool::start | ( |  | ) |
| virtual

Definition at line 72 of file AlgResourcePool.cpp.

72 {
73
74 StatusCode startSc = Service::start();
75 if ( ! startSc.isSuccess() ) return startSc;
76
77 // sys-Start the algos
78 for (auto& ialgo : m_algList){
79 startSc = ialgo->sysStart();
80 if (startSc.isFailure()){
81 error() << "Unable to start Algorithm: " << ialgo->name() << endmsg;
82 return startSc;
83 }
84 }
85 return StatusCode::SUCCESS;
86 }
Service::start
StatusCode start() override
Definition: Service.cpp:152
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
StatusCode::SUCCESS
Definition: StatusCode.h:30
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:87
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244

StatusCode AlgResourcePool::stop | ( |  | ) |
| virtual

Definition at line 425 of file AlgResourcePool.cpp.

425 {
426
427 StatusCode stopSc = Service::stop();
428 if ( ! stopSc.isSuccess() ) return stopSc;
429
430 // sys-Stop the algos
431 for (auto& ialgo : m_algList){
432 stopSc = ialgo->sysStop();
433 if (stopSc.isFailure()){
434 error() << "Unable to stop Algorithm: " << ialgo->name() << endmsg;
435 return stopSc;
436 }
437 }
438 return StatusCode::SUCCESS;
439 }
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Service::stop
StatusCode stop() override
Definition: Service.cpp:146
AlgResourcePool::m_algList
ListAlg m_algList
The list of all algorithms created withing the Pool which are not top.
Definition: AlgResourcePool.h:87
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 87 of file AlgResourcePool.h.

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

Definition at line 71 of file AlgResourcePool.h.

state_type AlgResourcePool::m_available_resources
| private

Definition at line 70 of file AlgResourcePool.h.

concurrency::ExecutionFlowGraph* AlgResourcePool::m_EFGraph
| private

OMG yet another hack.

Definition at line 102 of file AlgResourcePool.h.

ListAlg AlgResourcePool::m_flatUniqueAlgList
| private

The flat list of algorithms w/o clones.

Definition at line 93 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 96 of file AlgResourcePool.h.

bool AlgResourcePool::m_lazyCreation
| private

Definition at line 69 of file AlgResourcePool.h.

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

Definition at line 73 of file AlgResourcePool.h.

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

Definition at line 74 of file AlgResourcePool.h.

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

Definition at line 75 of file AlgResourcePool.h.

std::mutex AlgResourcePool::m_resource_mutex
| private

Definition at line 68 of file AlgResourcePool.h.

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

Definition at line 72 of file AlgResourcePool.h.

ListAlg AlgResourcePool::m_topAlgList
| private

The list of top algorithms.

Definition at line 90 of file AlgResourcePool.h.

StringArrayProperty AlgResourcePool::m_topAlgNames
| private

The names of the algorithms to be passed to the algorithm manager.

Definition at line 84 of file AlgResourcePool.h.

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

The top list of algorithms.

Definition at line 99 of file AlgResourcePool.h.

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

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