AlgResourcePool Class Reference

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

#include <GaudiHive/AlgResourcePool.h>

Inheritance diagram for AlgResourcePool:

Collaboration diagram for AlgResourcePool:

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	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...
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
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, 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
Public Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream) More...
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...
MSG::Level	outputLevel () const
	Backward compatibility function for getting the output level. More...
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...

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 (Gaudi::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
using	Factory = Gaudi::PluginService::Factory< IService *(const std::string &, ISvcLocator *)>
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 () const
	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, " 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 39 of file AlgResourcePool.h.

Member Typedef Documentation

concurrentQueueIAlgPtr

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

private

Definition at line 63 of file AlgResourcePool.h.

ListAlg

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

private

Definition at line 64 of file AlgResourcePool.h.

state_type

typedef boost::dynamic_bitset AlgResourcePool::state_type

private

Definition at line 65 of file AlgResourcePool.h.

Constructor & Destructor Documentation

~AlgResourcePool()

AlgResourcePool::~AlgResourcePool ( )

override

Definition at line 30 of file AlgResourcePool.cpp.

                                  {
  for ( auto& algoId_algoQueue : m_algqueue_map ) {
    auto* queue = algoId_algoQueue.second;
    delete queue;
  }
}

Member Function Documentation

acquireAlgorithm()

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

override

Acquire a certain algorithm using its name.

Definition at line 81 of file AlgResourcePool.cpp.

                                                                                                      {

  std::hash<std::string> hash_function;
  size_t                 algo_id        = hash_function( name );
  auto                   itQueueIAlgPtr = m_algqueue_map.find( algo_id );

  if ( itQueueIAlgPtr == m_algqueue_map.end() ) {
    error() << "Algorithm " << name << " requested, but not recognised" << endmsg;
    algo = nullptr;
    return StatusCode::FAILURE;
  }

  StatusCode sc;
  if ( blocking ) {
    itQueueIAlgPtr->second->pop( algo );
  } else {
    if ( !itQueueIAlgPtr->second->try_pop( algo ) ) { sc = StatusCode::FAILURE; }
  }

  // Note that reentrant algos are not consumed so we put them
  // back immediately in the queue at the end of this function.
  // Now we may still be called again in between and get this
  // error. In such a case, the Scheduler will retry later.
  // This is of course not optimal, but should only happen very
  // seldom and thud won't affect the global efficiency
  if ( sc.isFailure() )
    DEBUG_MSG << "No instance of algorithm " << name << " could be retrieved in non-blocking mode" << endmsg;

  // if (m_lazyCreation ) {
  //    TODO: fill the lazyCreation part
  // }
  if ( sc.isSuccess() ) {
    state_type requirements = m_resource_requirements[algo_id];
    m_resource_mutex.lock();
    if ( requirements.is_subset_of( m_available_resources ) ) {
      m_available_resources ^= requirements;
    } else {
      sc = StatusCode::FAILURE;
      error() << "Failure to allocate resources of algorithm " << name << endmsg;
      // in case of not reentrant, push it back. Reentrant ones are pushed back
      // in all cases further down
      if ( 0 != algo->cardinality() ) { itQueueIAlgPtr->second->push( algo ); }
    }
    m_resource_mutex.unlock();
    if ( 0 == algo->cardinality() ) {
      // push back reentrant algos immediately as it can be reused
      itQueueIAlgPtr->second->push( algo );
    }
  }
  return sc;
}

acquireResource()

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

override

Acquire a certain resource.

Definition at line 152 of file AlgResourcePool.cpp.

                                                                   {
  m_resource_mutex.lock();
  m_available_resources[m_resource_indices[name]] = false;
  m_resource_mutex.unlock();
  return StatusCode::SUCCESS;
}

decodeTopAlgs()

StatusCode AlgResourcePool::decodeTopAlgs ( )

private

Decode the top alg list.

Definition at line 203 of file AlgResourcePool.cpp.

                                          {

  SmartIF<IAlgManager> algMan( serviceLocator() );
  if ( !algMan.isValid() ) {
    error() << "Algorithm manager could not be properly fetched." << endmsg;
    return StatusCode::FAILURE;
  }

  // Useful lambda not to repeat ourselves --------------------------
  auto createAlg = [&algMan, this]( const std::string& item_type, const std::string& item_name, IAlgorithm*& algo ) {
    StatusCode createAlgSc = algMan->createAlgorithm( item_type, item_name, algo, true, false );
    if ( createAlgSc.isFailure() )
      this->warning() << "Algorithm " << item_type << "/" << item_name << " could not be created." << endmsg;
  };
  // End of lambda --------------------------------------------------

  StatusCode sc = StatusCode::SUCCESS;

  // Fill the top alg list ----
  const std::vector<std::string>& topAlgNames = m_topAlgNames.value();
  for ( auto& name : topAlgNames ) {
    IAlgorithm* algo( nullptr );

    Gaudi::Utils::TypeNameString item( name );
    const std::string&           item_name = item.name();
    const std::string&           item_type = item.type();
    SmartIF<IAlgorithm>          algoSmartIF( algMan->algorithm( item_name, false ) );

    if ( !algoSmartIF.isValid() ) {
      createAlg( item_type, item_name, algo );
      algoSmartIF = algo;
    }
    // Init and start
    algoSmartIF->sysInitialize().ignore();
    m_topAlgList.push_back( algoSmartIF );
  }
  // Top Alg list filled ----

  // Now we unroll it ----
  for ( auto& algoSmartIF : m_topAlgList ) {
    Gaudi::Algorithm* algorithm = dynamic_cast<Gaudi::Algorithm*>( algoSmartIF.get() );
    if ( !algorithm ) {
      fatal() << "Conversion from IAlgorithm to Gaudi::Algorithm failed" << endmsg;
      return StatusCode::FAILURE;
    }
    sc = flattenSequencer( algorithm, m_flatUniqueAlgList );
  }
  // stupid O(N^2) unique-ification..
  for ( auto i = begin( m_flatUniqueAlgList ); i != end( m_flatUniqueAlgList ); ++i ) {
    auto n = next( i );
    while ( n != end( m_flatUniqueAlgList ) ) {
      if ( *n == *i )
        n = m_flatUniqueAlgList.erase( n );
      else
        ++n;
    }
  }
  if ( msgLevel( MSG::DEBUG ) ) {
    debug() << "List of algorithms is: " << endmsg;
    for ( auto& algo : m_flatUniqueAlgList )
      debug() << "  o " << algo->type() << "/" << algo->name() << " @ " << algo << endmsg;
  }

  // Unrolled ---

  // Now let's manage the clones
  unsigned int           resource_counter( 0 );
  std::hash<std::string> hash_function;
  for ( auto& ialgoSmartIF : m_flatUniqueAlgList ) {

    const std::string& item_name = ialgoSmartIF->name();

    verbose() << "Treating resource management and clones of " << item_name << endmsg;

    Gaudi::Algorithm* algo = dynamic_cast<Gaudi::Algorithm*>( ialgoSmartIF.get() );
    if ( !algo ) {
      fatal() << "Conversion from IAlgorithm to Gaudi::Algorithm failed" << endmsg;
      return StatusCode::FAILURE;
    }
    const std::string& item_type = algo->type();

    size_t                  algo_id = hash_function( item_name );
    concurrentQueueIAlgPtr* queue   = new concurrentQueueIAlgPtr();
    m_algqueue_map[algo_id]         = queue;

    // DP TODO Do it properly with SmartIFs, also in the queues
    IAlgorithm* ialgo( ialgoSmartIF.get() );

    queue->push( ialgo );
    m_algList.push_back( ialgo );
    if ( ialgo->isReEntrant() ) {
      if ( ialgo->cardinality() != 0 ) {
        info() << "Algorithm " << ialgo->name() << " is ReEntrant, but Cardinality was set to " << ialgo->cardinality()
               << endmsg;
        m_n_of_allowed_instances[algo_id] = ialgo->cardinality();
      } else {
        m_n_of_allowed_instances[algo_id] = 1;
      }
    } else if ( ialgo->isClonable() ) {
      m_n_of_allowed_instances[algo_id] = ialgo->cardinality();
    } else {
      if ( ialgo->cardinality() == 1 ) {
        m_n_of_allowed_instances[algo_id] = 1;
      } else {
        if ( !m_overrideUnClonable ) {
          info() << "Algorithm " << ialgo->name() << " is un-Clonable but Cardinality was set to "
                 << ialgo->cardinality() << ". Only creating 1 instance" << endmsg;
          m_n_of_allowed_instances[algo_id] = 1;
        } else {
          warning() << "Overriding UnClonability of Algorithm " << ialgo->name() << ". Setting Cardinality to "
                    << ialgo->cardinality() << endmsg;
          m_n_of_allowed_instances[algo_id] = ialgo->cardinality();
        }
      }
    }
    m_n_of_created_instances[algo_id] = 1;

    state_type requirements( 0 );

    for ( auto& resource_name : ialgo->neededResources() ) {
      auto ret = m_resource_indices.emplace( resource_name, resource_counter );
      // insert successful means == wasn't known before. So increment counter
      if ( ret.second ) ++resource_counter;
      // Resize for every algo according to the found resources
      requirements.resize( resource_counter );
      // in any case the return value holds the proper product index
      requirements[ret.first->second] = true;
    }

    m_resource_requirements[algo_id] = requirements;

    // potentially create clones; if not lazy creation we have to do it now
    if ( !m_lazyCreation ) {
      for ( unsigned int i = 1, end = m_n_of_allowed_instances[algo_id]; i < end; ++i ) {
        debug() << "type/name to create clone of: " << item_type << "/" << item_name << endmsg;
        IAlgorithm* ialgoClone( nullptr );
        createAlg( item_type, item_name, ialgoClone );
        ialgoClone->setIndex( i );
        if ( ialgoClone->sysInitialize().isFailure() ) {
          error() << "unable to initialize Algorithm clone " << ialgoClone->name() << endmsg;
          sc = StatusCode::FAILURE;
          // FIXME: should we delete this failed clone?
        } else {
          queue->push( ialgoClone );
          m_n_of_created_instances[algo_id] += 1;
        }
      }
    }
  }

  // Now resize all the requirement bitsets to the same size
  for ( auto& kv : m_resource_requirements ) { kv.second.resize( resource_counter ); }

  // Set all resources to be available
  m_available_resources.resize( resource_counter );
  m_available_resources.set();

  return sc;
}

flattenSequencer()

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

private

Recursively flatten an algList.

Definition at line 170 of file AlgResourcePool.cpp.

                                                                                                                  {

  StatusCode sc = StatusCode::SUCCESS;

  if ( algo->isSequence() ) {
    auto seq = dynamic_cast<Gaudi::Sequence*>( algo );
    if ( seq == 0 ) {
      error() << "Unable to dcast Algorithm " << algo->name() << " to a Sequence, but it has isSequence==true"
              << endmsg;
      return StatusCode::FAILURE;
    }

    auto subAlgorithms = seq->subAlgorithms();

    // Recursively unroll
    ++recursionDepth;

    for ( auto subalgo : *subAlgorithms ) {
      sc = flattenSequencer( subalgo, alglist, recursionDepth );
      if ( sc.isFailure() ) {
        error() << "Algorithm " << subalgo->name() << " could not be flattened" << endmsg;
        return sc;
      }
    }
  } else {
    alglist.emplace_back( algo );
    return sc;
  }
  return sc;
}

getFlatAlgList()

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

override

Definition at line 365 of file AlgResourcePool.cpp.

                                                     {
  m_flatUniqueAlgPtrList.clear();
  for ( auto algoSmartIF : m_flatUniqueAlgList ) m_flatUniqueAlgPtrList.push_back( algoSmartIF.get() );
  return m_flatUniqueAlgPtrList;
}

getTopAlgList()

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

override

Definition at line 373 of file AlgResourcePool.cpp.

                                                    {
  m_topAlgPtrList.clear();
  for ( auto algoSmartIF : m_topAlgList ) m_topAlgPtrList.push_back( algoSmartIF.get() );
  return m_topAlgPtrList;
}

initialize()

StatusCode AlgResourcePool::initialize ( )

override

Definition at line 40 of file AlgResourcePool.cpp.

                                       {

  StatusCode sc( Service::initialize() );
  if ( !sc.isSuccess() ) warning() << "Base class could not be started" << endmsg;

  // Try to recover the topAlgList from the ApplicationManager for backward-compatibility
  if ( m_topAlgNames.value().empty() ) {
    info() << "TopAlg list empty. Recovering the one of Application Manager" << endmsg;
    const Gaudi::Utils::TypeNameString appMgrName( "ApplicationMgr/ApplicationMgr" );
    SmartIF<IProperty>                 appMgrProps( serviceLocator()->service( appMgrName ) );
    m_topAlgNames.assign( appMgrProps->getProperty( "TopAlg" ) );
  }

  sc = decodeTopAlgs();
  if ( sc.isFailure() ) warning() << "Algorithms could not be properly decoded." << endmsg;

  // let's assume all resources are there
  m_available_resources.set();
  return StatusCode::SUCCESS;
}

releaseAlgorithm()

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

override

Release a certain algorithm.

Definition at line 135 of file AlgResourcePool.cpp.

                                                                                       {

  std::hash<std::string> hash_function;
  size_t                 algo_id = hash_function( name );

  // release resources used by the algorithm
  m_resource_mutex.lock();
  m_available_resources |= m_resource_requirements[algo_id];
  m_resource_mutex.unlock();

  // release algorithm itself if not reentrant
  if ( 0 != algo->cardinality() ) { m_algqueue_map[algo_id]->push( algo ); }
  return StatusCode::SUCCESS;
}

releaseResource()

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

override

Release a certrain resource.

Definition at line 161 of file AlgResourcePool.cpp.

                                                                   {
  m_resource_mutex.lock();
  m_available_resources[m_resource_indices[name]] = true;
  m_resource_mutex.unlock();
  return StatusCode::SUCCESS;
}

start()

StatusCode AlgResourcePool::start ( )

override

Definition at line 63 of file AlgResourcePool.cpp.

                                  {

  StatusCode startSc = Service::start();
  if ( !startSc.isSuccess() ) return startSc;

  // sys-Start the algos
  for ( auto& ialgo : m_algList ) {
    startSc = ialgo->sysStart();
    if ( startSc.isFailure() ) {
      error() << "Unable to start Algorithm: " << ialgo->name() << endmsg;
      return startSc;
    }
  }
  return StatusCode::SUCCESS;
}

stop()

StatusCode AlgResourcePool::stop ( )

override

Definition at line 381 of file AlgResourcePool.cpp.

                                 {

  StatusCode stopSc = Service::stop();
  if ( !stopSc.isSuccess() ) return stopSc;

  // sys-Stop the algos
  for ( auto& ialgo : m_algList ) {
    stopSc = ialgo->sysStop();
    if ( stopSc.isFailure() ) {
      error() << "Unable to stop Algorithm: " << ialgo->name() << endmsg;
      return stopSc;
    }
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_algList

ListAlg AlgResourcePool::m_algList

private

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

Definition at line 89 of file AlgResourcePool.h.

m_algqueue_map

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

private

Definition at line 70 of file AlgResourcePool.h.

m_available_resources

state_type AlgResourcePool::m_available_resources {0}

private

Definition at line 69 of file AlgResourcePool.h.

m_flatUniqueAlgList

ListAlg AlgResourcePool::m_flatUniqueAlgList

private

The flat list of algorithms w/o clones.

Definition at line 95 of file AlgResourcePool.h.

m_flatUniqueAlgPtrList

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

private

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

Definition at line 98 of file AlgResourcePool.h.

m_lazyCreation

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

private

Definition at line 82 of file AlgResourcePool.h.

m_n_of_allowed_instances

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

private

Definition at line 72 of file AlgResourcePool.h.

m_n_of_created_instances

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

private

Definition at line 73 of file AlgResourcePool.h.

m_overrideUnClonable

Gaudi::Property<bool> AlgResourcePool::m_overrideUnClonable

private

Initial value:

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

Definition at line 85 of file AlgResourcePool.h.

m_resource_indices

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

private

Definition at line 74 of file AlgResourcePool.h.

m_resource_mutex

std::mutex AlgResourcePool::m_resource_mutex

private

Definition at line 67 of file AlgResourcePool.h.

m_resource_requirements

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

private

Definition at line 71 of file AlgResourcePool.h.

m_topAlgList

ListAlg AlgResourcePool::m_topAlgList

private

The list of top algorithms.

Definition at line 92 of file AlgResourcePool.h.

m_topAlgNames

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 83 of file AlgResourcePool.h.

m_topAlgPtrList

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

private

The top list of algorithms.

Definition at line 101 of file AlgResourcePool.h.

---

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

• GaudiHive/src/AlgResourcePool.h
• GaudiHive/src/AlgResourcePool.cpp