AlgResourcePool Class Reference

#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 (std::string_view name, IAlgorithm *&algo, bool blocking=false) override
	Acquire a certain algorithm using its name. More...
StatusCode	releaseAlgorithm (std::string_view name, IAlgorithm *&algo) override
	Release a certain algorithm. More...
StatusCode	acquireResource (std::string_view name) override
	Acquire a certain resource. More...
StatusCode	releaseResource (std::string_view name) override
	Release a certain resource. More...
std::list< IAlgorithm * >	getFlatAlgList () override
std::list< IAlgorithm * >	getTopAlgList () override
StatusCode	stop () override
StatusCode	finalize () 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...
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 >
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")
template<class T >
StatusCode	declareTool (ToolHandle< T > &handle, bool createIf=true)
template<class T >
StatusCode	declareTool (ToolHandle< T > &handle, const std::string &toolTypeAndName, bool createIf=true)
	Declare used tool. More...
template<class T >
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandleArray< T > &hndlArr, const std::string &doc="none")
template<class T >
void	addToolsArray (ToolHandleArray< T > &hndlArr)
const std::vector< IAlgTool * > &	tools () const
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, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation. More...
	requires (!Gaudi::Details::is_gaudi_property_v< TYPE >) Gaudi
	Helper to wrap a regular data member and use it as a regular property. More...
Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property. More...
StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name More...
StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string More...
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property. More...
virtual StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p)=0
	Set the property from a property with a different name. More...
virtual StatusCode	setProperty (const std::string &s)=0
	Set the property by string. More...
StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals. More...
StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string. More...
StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation More...
StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property More...
const Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name More...
StatusCode	getProperty (std::string_view 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 (std::string_view name) const override
	Return true if we have a property with the given name. More...
Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected More...
void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)
	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...

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 Algorithm list. More...
StatusCode	flattenSequencer (Gaudi::Algorithm *sequencer, ListAlg &alglist, unsigned int recursionDepth=0)
	Recursively flatten an algList. More...
void	dumpInstanceMisses () const
	Dump recorded Algorithm instance misses. 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_view, unsigned int >	m_resource_indices
std::unordered_map< std::string_view, unsigned int >	m_algInstanceMisses
	Counters for Algorithm instance misses. More...
Gaudi::Property< bool >	m_lazyCreation { this, "CreateLazily", false, "" }
Gaudi::Property< std::vector< std::string > >	m_topAlgNames
Gaudi::Property< bool >	m_overrideUnClonable
Gaudi::Property< bool >	m_countAlgInstMisses
ListAlg	m_algList
	The list of all algorithms created within 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
std::vector< IAlgTool * > &	tools ()
	~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 > >
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" }
	flag indicating whether ToolHandle tools have been added to m_tools More...
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()" }
Gaudi::Property< bool >	m_autoRetrieveTools
Gaudi::Property< bool >	m_checkToolDeps
SmartIF< IAuditorSvc >	m_pAuditorSvc
	Auditor Service More...

Detailed Description

The AlgResourcePool is a concrete implementation of the IAlgResourcePool interface. It either creates all instances up front or lazily. Internal bookkeeping is done via hashes of the algorithm names.

Author

Benedikt Hegner

Definition at line 38 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 29 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 ( std::string_view  name, IAlgorithm *&  algo, bool  blocking = false  )

override

Acquire a certain algorithm using its name.

Definition at line 80 of file AlgResourcePool.cpp.

                                                                                                    {
 
  std::hash<std::string_view> 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 ) ) {
      if ( m_countAlgInstMisses ) {
        auto result = m_algInstanceMisses.find( name );
        if ( result != m_algInstanceMisses.end() )
          ++( result->second );
        else
          m_algInstanceMisses[name] = 1;
      }
      sc = StatusCode::FAILURE;
    }
  }
 
  // Note that reentrant algorithms 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 ( !algo->isReEntrant() ) { itQueueIAlgPtr->second->push( algo ); }
    }
    m_resource_mutex.unlock();
    if ( algo->isReEntrant() ) {
      // push back reentrant algorithms immediately as it can be reused
      itQueueIAlgPtr->second->push( algo );
    }
  }
  return sc;
}

acquireResource()

StatusCode AlgResourcePool::acquireResource ( std::string_view  name )

override

Acquire a certain resource.

Definition at line 160 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 Algorithm list.

Definition at line 211 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 algorithm 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;
    }
 
    algoSmartIF->sysInitialize().ignore();
    m_topAlgList.push_back( algoSmartIF );
  }
  // Top algorithm 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()
               << ". Only creating 1 instance" << endmsg;
      }
      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 algorithm 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;
}

dumpInstanceMisses()

void AlgResourcePool::dumpInstanceMisses ( ) const

private

Dump recorded Algorithm instance misses.

Definition at line 386 of file AlgResourcePool.cpp.

                                               {
 
  std::multimap<unsigned int, std::string_view, std::greater<unsigned int>> sortedAlgInstanceMisses;
 
  for ( auto& p : m_algInstanceMisses ) sortedAlgInstanceMisses.insert( { p.second, p.first } );
 
  // determine optimal indentation
  int indnt = std::to_string( sortedAlgInstanceMisses.cbegin()->first ).length();
 
  std::ostringstream out;
 
  out << "Hit parade of algorithm instance misses:\n"
      << std::right << std::setfill( ' ' )
      << " ===============================================================================\n"
      << std::setw( indnt + 7 ) << "Misses "
      << "| Algorithm (# of clones) \n"
      << " ===============================================================================\n";
 
  std::hash<std::string_view> hash_function;
 
  out << std::right << std::setfill( ' ' );
  for ( const auto& p : sortedAlgInstanceMisses ) {
    out << std::setw( indnt + 7 ) << std::to_string( p.first ) + " "
        << "  " << p.second << " (" << m_n_of_allowed_instances.at( hash_function( p.second ) ) << ")\n";
  }
 
  info() << out.str() << endmsg;
}

finalize()

StatusCode AlgResourcePool::finalize ( )

override

Definition at line 435 of file AlgResourcePool.cpp.

                                     {
  // we do not need to hold the ref counts of the algorithms anymore
  // (this triggers algorithms destructors)
  m_topAlgList.clear();
  m_algList.clear();
  m_flatUniqueAlgList.clear();
  return extends::finalize();
}

flattenSequencer()

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

private

Recursively flatten an algList.

Definition at line 178 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 371 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 379 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 39 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 ( std::string_view  name, IAlgorithm *&  algo  )

override

Release a certain algorithm.

Definition at line 143 of file AlgResourcePool.cpp.

                                                                                     {
 
  std::hash<std::string_view> 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 ( !algo->isReEntrant() ) { m_algqueue_map[algo_id]->push( algo ); }
  return StatusCode::SUCCESS;
}

releaseResource()

StatusCode AlgResourcePool::releaseResource ( std::string_view  name )

override

Release a certain resource.

Definition at line 169 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 62 of file AlgResourcePool.cpp.

                                  {
 
  StatusCode startSc = Service::start();
  if ( !startSc.isSuccess() ) return startSc;
 
  // sys-Start the algorithms
  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 417 of file AlgResourcePool.cpp.

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

Member Data Documentation

m_algInstanceMisses

std::unordered_map<std::string_view, unsigned int> AlgResourcePool::m_algInstanceMisses

private

Counters for Algorithm instance misses.

Definition at line 85 of file AlgResourcePool.h.

m_algList

ListAlg AlgResourcePool::m_algList

private

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

Definition at line 97 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_countAlgInstMisses

Gaudi::Property<bool> AlgResourcePool::m_countAlgInstMisses

private

Initial value:

{
      this, "CountAlgorithmInstanceMisses", false,
      "Count and print out algorithm instance misses. Useful for finding ways to improve throughput scalability." }

Definition at line 92 of file AlgResourcePool.h.

m_flatUniqueAlgList

ListAlg AlgResourcePool::m_flatUniqueAlgList

private

The flat list of algorithms w/o clones.

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

m_lazyCreation

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

private

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

m_resource_indices

std::map<std::string_view, 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 100 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 88 of file AlgResourcePool.h.

m_topAlgPtrList

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

private

The top list of algorithms.

Definition at line 109 of file AlgResourcePool.h.

---

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

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