| The Gaudi Framework v30r0 (c919700c)

- 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
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 | declareTool (ToolHandle< T > &handle, std::string toolTypeAndName, bool createIf=true)
| Declare used 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...
const 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 cached level (originally extracted 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, 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
Gaudi::Property< bool > | m_overrideUnClonable
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...

## 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 > >
MSG::Level | setUpMessaging ()
| Set up local caches. More...
MSG::Level | resetMessaging ()
| Reinitialize internal states. More...
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 29 of file AlgResourcePool.h.

## Member Typedef Documentation

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

Definition at line 57 of file AlgResourcePool.h.

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

Definition at line 58 of file AlgResourcePool.h.

typedef boost::dynamic_bitset AlgResourcePool::state_type
| private

Definition at line 59 of file AlgResourcePool.h.

## Constructor & Destructor Documentation

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

Definition at line 25 of file AlgResourcePool.cpp.

26 {
27
28 for ( auto& algoId_algoQueue : m_algqueue_map ) {
29 auto* queue = algoId_algoQueue.second;
30 delete queue;
31 }
32 }
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:64

## 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 80 of file AlgResourcePool.cpp.

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

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

Acquire a certain resource.

Definition at line 159 of file AlgResourcePool.cpp.

160 {
161 m_resource_mutex.lock();
162 m_available_resources[m_resource_indices[name]] = false;
163 m_resource_mutex.unlock();
164 return StatusCode::SUCCESS;
165 }
StatusCode::SUCCESS
Definition: StatusCode.h:29
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:68
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:61
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:63
std::mutex::lock
T lock(T...args)

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

Definition at line 388 of file AlgResourcePool.cpp.

389 {
390 auto algBeginRun = [&]( SmartIF<IAlgorithm>& algoSmartIF ) -> StatusCode {
391 StatusCode sc = algoSmartIF->sysBeginRun();
392 if ( !sc.isSuccess() ) {
393 warning() << "beginRun() of algorithm " << algoSmartIF->name() << " failed" << endmsg;
394 return StatusCode::FAILURE;
395 }
396 return StatusCode::SUCCESS;
397 };
398 // Call the beginRun() method of all algorithms
399 for ( auto& algoSmartIF : m_flatUniqueAlgList ) {
400 if ( algBeginRun( algoSmartIF ).isFailure() ) return StatusCode::FAILURE;
401 }
402
403 return StatusCode::SUCCESS;
404 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:89
StatusCode::SUCCESS
Definition: StatusCode.h:29
SmartIF< IAlgorithm >
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:109
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
StatusCode::FAILURE
Definition: StatusCode.h:29
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

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

Decode the top alg list.

Definition at line 218 of file AlgResourcePool.cpp.

219 {
220
221 SmartIF<IAlgManager> algMan( serviceLocator() );
222 if ( !algMan.isValid() ) {
223 error() << "Algorithm manager could not be properly fetched." << endmsg;
224 return StatusCode::FAILURE;
225 }
226
227 // Useful lambda not to repeat ourselves --------------------------
228 auto createAlg = [&algMan, this]( const std::string& item_type, const std::string& item_name, IAlgorithm*& algo ) {
229 StatusCode createAlgSc = algMan->createAlgorithm( item_type, item_name, algo, true, false );
230 if ( createAlgSc.isFailure() )
231 this->warning() << "Algorithm " << item_type << "/" << item_name << " could not be created." << endmsg;
232 };
233 // End of lambda --------------------------------------------------
234
235 StatusCode sc = StatusCode::SUCCESS;
236
237 // Fill the top alg list ----
238 const std::vector<std::string>& topAlgNames = m_topAlgNames.value();
239 for ( auto& name : topAlgNames ) {
240 IAlgorithm* algo( nullptr );
241
242 Gaudi::Utils::TypeNameString item( name );
243 const std::string& item_name = item.name();
244 const std::string& item_type = item.type();
245 SmartIF<IAlgorithm> algoSmartIF( algMan->algorithm( item_name, false ) );
246
247 if ( !algoSmartIF.isValid() ) {
248 createAlg( item_type, item_name, algo );
249 algoSmartIF = algo;
250 }
251 // Init and start
252 algoSmartIF->sysInitialize().ignore();
253 m_topAlgList.push_back( algoSmartIF );
254 }
255 // Top Alg list filled ----
256
257 // Now we unroll it ----
258 for ( auto& algoSmartIF : m_topAlgList ) {
259 Algorithm* algorithm = dynamic_cast<Algorithm*>( algoSmartIF.get() );
260 if ( !algorithm ) fatal() << "Conversion from IAlgorithm to Algorithm failed" << endmsg;
261 sc = flattenSequencer( algorithm, m_flatUniqueAlgList );
262 }
263 // stupid O(N^2) unique-ification..
264 for ( auto i = begin( m_flatUniqueAlgList ); i != end( m_flatUniqueAlgList ); ++i ) {
265 auto n = next( i );
266 while ( n != end( m_flatUniqueAlgList ) ) {
267 if ( *n == *i )
268 n = m_flatUniqueAlgList.erase( n );
269 else
270 ++n;
271 }
272 }
273 if ( msgLevel( MSG::DEBUG ) ) {
274 debug() << "List of algorithms is: " << endmsg;
275 for ( auto& algo : m_flatUniqueAlgList )
276 debug() << " o " << algo->type() << "/" << algo->name() << " @ " << algo << endmsg;
277 }
278
279 // Unrolled ---
280
281 // Now let's manage the clones
282 unsigned int resource_counter( 0 );
283 std::hash<std::string> hash_function;
284 for ( auto& ialgoSmartIF : m_flatUniqueAlgList ) {
285
286 const std::string& item_name = ialgoSmartIF->name();
287
288 verbose() << "Treating resource management and clones of " << item_name << endmsg;
289
290 Algorithm* algo = dynamic_cast<Algorithm*>( ialgoSmartIF.get() );
291 if ( !algo ) fatal() << "Conversion from IAlgorithm to Algorithm failed" << endmsg;
292 const std::string& item_type = algo->type();
293
294 size_t algo_id = hash_function( item_name );
295 concurrentQueueIAlgPtr* queue = new concurrentQueueIAlgPtr();
296 m_algqueue_map[algo_id] = queue;
297
298 // DP TODO Do it properly with SmartIFs, also in the queues
299 IAlgorithm* ialgo( ialgoSmartIF.get() );
300
301 queue->push( ialgo );
302 m_algList.push_back( ialgo );
303 if ( ialgo->isClonable() ) {
304 m_n_of_allowed_instances[algo_id] = ialgo->cardinality();
305 } else {
306 if ( ialgo->cardinality() == 1 ) {
307 m_n_of_allowed_instances[algo_id] = 1;
308 } else {
309 if ( !m_overrideUnClonable ) {
310 info() << "Algorithm " << ialgo->name() << " is un-Clonable but Cardinality was set to "
311 << ialgo->cardinality() << ". Only creating 1 instance" << endmsg;
312 m_n_of_allowed_instances[algo_id] = 1;
313 } else {
314 warning() << "Overriding UnClonability of Algorithm " << ialgo->name() << ". Setting Cardinality to "
315 << ialgo->cardinality() << endmsg;
316 m_n_of_allowed_instances[algo_id] = ialgo->cardinality();
317 }
318 }
319 }
320 m_n_of_created_instances[algo_id] = 1;
321
322 state_type requirements( 0 );
323
324 for ( auto& resource_name : ialgo->neededResources() ) {
325 auto ret = m_resource_indices.emplace( resource_name, resource_counter );
326 // insert successful means == wasn't known before. So increment counter
327 if ( ret.second ) ++resource_counter;
328 // Resize for every algo according to the found resources
329 requirements.resize( resource_counter );
330 // in any case the return value holds the proper product index
331 requirements[ret.first->second] = true;
332 }
333
334 m_resource_requirements[algo_id] = requirements;
335
336 // potentially create clones; if not lazy creation we have to do it now
337 if ( !m_lazyCreation ) {
338 for ( unsigned int i = 1, end = m_n_of_allowed_instances[algo_id]; i < end; ++i ) {
339 debug() << "type/name to create clone of: " << item_type << "/" << item_name << endmsg;
340 IAlgorithm* ialgoClone( nullptr );
341 createAlg( item_type, item_name, ialgoClone );
342 ialgoClone->setIndex( i );
343 if ( ialgoClone->sysInitialize().isFailure() ) {
344 error() << "unable to initialize Algorithm clone " << ialgoClone->name() << endmsg;
345 sc = StatusCode::FAILURE;
346 // FIXME: should we delete this failed clone?
347 } else {
348 queue->push( ialgoClone );
349 m_n_of_created_instances[algo_id] += 1;
350 }
351 }
352 }
353 }
354
355 // Now resize all the requirement bitsets to the same size
356 for ( auto& kv : m_resource_requirements ) {
357 kv.second.resize( resource_counter );
358 }
359
360 // Set all resources to be available
361 m_available_resources.resize( resource_counter );
362 m_available_resources.set();
363
364 return sc;
365 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:89
StatusCode::SUCCESS
Definition: StatusCode.h:29
SmartIF< IAlgManager >
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:112
AlgResourcePool::m_resource_indices
std::map< std::string, unsigned int > m_resource_indices
Definition: AlgResourcePool.h:68
AlgResourcePool::flattenSequencer
StatusCode flattenSequencer(Algorithm *sequencer, ListAlg &alglist, unsigned int recursionDepth=0)
Recursively flatten an algList.
Definition: AlgResourcePool.cpp:179
CommonMessagingBase::verbose
MsgStream & verbose() const
shortcut for the method msgStream(MSG::VERBOSE)
Definition: CommonMessaging.h:118
MSG::DEBUG
Definition: IMessageSvc.h:16
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:63
AlgResourcePool::m_overrideUnClonable
Gaudi::Property< bool > m_overrideUnClonable
Definition: AlgResourcePool.h:79
begin
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:58
std::string
STL class.
GaudiPluginService.cpluginsvc.n
n
Definition: cpluginsvc.py:228
AlgResourcePool::state_type
boost::dynamic_bitset state_type
Definition: AlgResourcePool.h:59
std::list::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
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:109
AlgResourcePool::concurrentQueueIAlgPtr
tbb::concurrent_bounded_queue< IAlgorithm * > concurrentQueueIAlgPtr
Definition: AlgResourcePool.h:57
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:65
std::list::erase
T erase(T...args)
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:64
AlgResourcePool::m_topAlgNames
Gaudi::Property< std::vector< std::string > > m_topAlgNames
Definition: AlgResourcePool.h:77
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:28
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:64
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:79
std::vector< std::string >
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:115
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:67
StatusCode::FAILURE
Definition: StatusCode.h:29
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:100
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:86
Algorithm::type
const std::string & type() const override
The type of the algorithm object.
Definition: Algorithm.h:168
CommonMessagingBase::msgLevel
MSG::Level msgLevel() const
get the cached level (originally extracted from the embedded MsgStream)
Definition: CommonMessaging.h:124
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:66
AlgResourcePool::m_algList
ListAlg m_algList
The list of all algorithms created withing the Pool which are not top.
Definition: AlgResourcePool.h:83
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
AlgResourcePool::m_lazyCreation
Gaudi::Property< bool > m_lazyCreation
Definition: AlgResourcePool.h:76

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

Definition at line 408 of file AlgResourcePool.cpp.

409 {
410
411 auto algEndRun = [&]( SmartIF<IAlgorithm>& algoSmartIF ) -> StatusCode {
412 StatusCode sc = algoSmartIF->sysEndRun();
413 if ( !sc.isSuccess() ) {
414 warning() << "endRun() of algorithm " << algoSmartIF->name() << " failed" << endmsg;
415 return StatusCode::FAILURE;
416 }
417 return StatusCode::SUCCESS;
418 };
419 // Call the beginRun() method of all top algorithms
420 for ( auto& algoSmartIF : m_flatUniqueAlgList ) {
421 if ( algEndRun( algoSmartIF ).isFailure() ) return StatusCode::FAILURE;
422 }
423 for ( auto& algoSmartIF : m_topAlgList ) {
424 if ( algEndRun( algoSmartIF ).isFailure() ) return StatusCode::FAILURE;
425 }
426 return StatusCode::SUCCESS;
427 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:89
StatusCode::SUCCESS
Definition: StatusCode.h:29
SmartIF< IAlgorithm >
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:109
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
StatusCode::FAILURE
Definition: StatusCode.h:29
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:86
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

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

Recursively flatten an algList.

Definition at line 179 of file AlgResourcePool.cpp.

180 {
181
182 StatusCode sc = StatusCode::SUCCESS;
183
184 bool isGaudiSequencer( false );
185 bool isAthSequencer( false );
186
187 if ( algo->isSequence() ) {
188 if ( algo->hasProperty( "ShortCircuit" ) )
189 isGaudiSequencer = true;
190 else if ( algo->hasProperty( "StopOverride" ) )
191 isAthSequencer = true;
192 }
193
194 std::vector<Algorithm*>* subAlgorithms = algo->subAlgorithms();
195 if ( // we only want to add basic algorithms -> have no subAlgs
196 // and exclude the case of empty sequencers
197 ( subAlgorithms->empty() && !( isGaudiSequencer || isAthSequencer ) ) ) {
198
199 alglist.emplace_back( algo );
200 return sc;
201 }
202
203 // Recursively unroll
204 ++recursionDepth;
205
206 for ( Algorithm* subalgo : *subAlgorithms ) {
207 sc = flattenSequencer( subalgo, alglist, recursionDepth );
208 if ( sc.isFailure() ) {
209 error() << "Algorithm " << subalgo->name() << " could not be flattened" << endmsg;
210 return sc;
211 }
212 }
213 return sc;
214 }
StatusCode::SUCCESS
Definition: StatusCode.h:29
std::vector::empty
T empty(T...args)
AlgResourcePool::flattenSequencer
StatusCode flattenSequencer(Algorithm *sequencer, ListAlg &alglist, unsigned int recursionDepth=0)
Recursively flatten an algList.
Definition: AlgResourcePool.cpp:179
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
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:79
std::vector< Algorithm * >
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
std::vector::emplace_back
T emplace_back(T...args)

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

Definition at line 369 of file AlgResourcePool.cpp.

370 {
371 m_flatUniqueAlgPtrList.clear();
372 for ( auto algoSmartIF : m_flatUniqueAlgList )
373 m_flatUniqueAlgPtrList.push_back( const_cast<IAlgorithm*>( algoSmartIF.get() ) );
374 return m_flatUniqueAlgPtrList;
375 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:89
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:92
std::list::clear
T clear(T...args)

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

Definition at line 379 of file AlgResourcePool.cpp.

380 {
381 m_topAlgPtrList.clear();
382 for ( auto algoSmartIF : m_topAlgList ) m_topAlgPtrList.push_back( const_cast<IAlgorithm*>( algoSmartIF.get() ) );
383 return m_topAlgPtrList;
384 }
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:95
std::list::clear
T clear(T...args)
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:86

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

Definition at line 37 of file AlgResourcePool.cpp.

38 {
39
40 StatusCode sc( Service::initialize() );
41 if ( !sc.isSuccess() ) warning() << "Base class could not be started" << endmsg;
42
43 // Try to recover the topAlgList from the ApplicationManager for backward-compatibility
44 if ( m_topAlgNames.value().empty() ) {
45 info() << "TopAlg list empty. Recovering the one of Application Manager" << endmsg;
46 const Gaudi::Utils::TypeNameString appMgrName( "ApplicationMgr/ApplicationMgr" );
47 SmartIF<IProperty> appMgrProps( serviceLocator()->service( appMgrName ) );
48 m_topAlgNames.assign( appMgrProps->getProperty( "TopAlg" ) );
49 }
50
51 sc = decodeTopAlgs();
52 if ( sc.isFailure() ) warning() << "Algorithms could not be properly decoded." << endmsg;
53
54 // let's assume all resources are there
55 m_available_resources.set();
56 return StatusCode::SUCCESS;
57 }
StatusCode::SUCCESS
Definition: StatusCode.h:29
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:64
SmartIF< IProperty >
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:112
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:63
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:109
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:77
AlgResourcePool::decodeTopAlgs
StatusCode decodeTopAlgs()
Decode the top alg list.
Definition: AlgResourcePool.cpp:218
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
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:209

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

Release a certain algorithm.

Definition at line 139 of file AlgResourcePool.cpp.

140 {
141
142 std::hash<std::string> hash_function;
143 size_t algo_id = hash_function( name );
144
145 // release resources used by the algorithm
146 m_resource_mutex.lock();
147 m_available_resources |= m_resource_requirements[algo_id];
148 m_resource_mutex.unlock();
149
150 // release algorithm itself if not reentrant
151 if ( 0 != algo->cardinality() ) {
152 m_algqueue_map[algo_id]->push( algo );
153 }
154 return StatusCode::SUCCESS;
155 }
StatusCode::SUCCESS
Definition: StatusCode.h:29
std::mutex::unlock
T unlock(T...args)
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:61
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:63
std::hash
AlgResourcePool::m_resource_requirements
std::map< size_t, state_type > m_resource_requirements
Definition: AlgResourcePool.h:65
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:64

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

Release a certrain resource.

Definition at line 169 of file AlgResourcePool.cpp.

170 {
171 m_resource_mutex.lock();
172 m_available_resources[m_resource_indices[name]] = true;
173 m_resource_mutex.unlock();
174 return StatusCode::SUCCESS;
175 }
StatusCode::SUCCESS
Definition: StatusCode.h:29
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:68
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:61
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:63
std::mutex::lock
T lock(T...args)

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

Definition at line 61 of file AlgResourcePool.cpp.

62 {
63
64 StatusCode startSc = Service::start();
65 if ( !startSc.isSuccess() ) return startSc;
66
67 // sys-Start the algos
68 for ( auto& ialgo : m_algList ) {
69 startSc = ialgo->sysStart();
70 if ( startSc.isFailure() ) {
71 error() << "Unable to start Algorithm: " << ialgo->name() << endmsg;
72 return startSc;
73 }
74 }
75 return StatusCode::SUCCESS;
76 }
StatusCode::SUCCESS
Definition: StatusCode.h:29
Service::start
StatusCode start() override
Definition: Service.cpp:137
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
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:83
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

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

Definition at line 431 of file AlgResourcePool.cpp.

432 {
433
434 StatusCode stopSc = Service::stop();
435 if ( !stopSc.isSuccess() ) return stopSc;
436
437 // sys-Stop the algos
438 for ( auto& ialgo : m_algList ) {
439 stopSc = ialgo->sysStop();
440 if ( stopSc.isFailure() ) {
441 error() << "Unable to stop Algorithm: " << ialgo->name() << endmsg;
442 return stopSc;
443 }
444 }
445 return StatusCode::SUCCESS;
446 }
StatusCode::SUCCESS
Definition: StatusCode.h:29
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
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:83
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209

## Member Data Documentation

ListAlg AlgResourcePool::m_algList
| private

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

Definition at line 83 of file AlgResourcePool.h.

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

Definition at line 64 of file AlgResourcePool.h.

state_type AlgResourcePool::m_available_resources {0}
| private

Definition at line 63 of file AlgResourcePool.h.

ListAlg AlgResourcePool::m_flatUniqueAlgList
| private

The flat list of algorithms w/o clones.

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

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

Definition at line 76 of file AlgResourcePool.h.

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

Definition at line 66 of file AlgResourcePool.h.

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

Definition at line 67 of file AlgResourcePool.h.

Gaudi::Property<bool> AlgResourcePool::m_overrideUnClonable
| private

Initial value:
{this, "OverrideUnClonable", false,
"override the Un-Clonability of Algorithms. Use with caution!"}

Definition at line 79 of file AlgResourcePool.h.

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

Definition at line 68 of file AlgResourcePool.h.

std::mutex AlgResourcePool::m_resource_mutex
| private

Definition at line 61 of file AlgResourcePool.h.

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

Definition at line 65 of file AlgResourcePool.h.

ListAlg AlgResourcePool::m_topAlgList
| private

The list of top algorithms.

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

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

The top list of algorithms.

Definition at line 95 of file AlgResourcePool.h.

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

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