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 (std::string_view name, IAlgorithm *&algo, bool blocking=false) override
	Acquire a certain algorithm using its name.
StatusCode	releaseAlgorithm (std::string_view name, IAlgorithm *&algo) override
	Release a certain algorithm.
StatusCode	acquireResource (std::string_view name, unsigned int value) override
	Acquire units of a certain resource.
StatusCode	releaseResource (std::string_view name, unsigned int value) override
	Release a certain resource.
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 const *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast.
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface.
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames.
Public Member Functions inherited from Service
const std::string &	name () const override
	Retrieve name of the service.
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.
StatusCode	sysStart () override
	Initialize Service.
StatusCode	sysStop () override
	Initialize Service.
StatusCode	sysFinalize () override
	Finalize Service.
StatusCode	sysReinitialize () override
	Re-initialize the Service.
StatusCode	sysRestart () override
	Re-initialize the Service.
	Service (std::string name, ISvcLocator *svcloc)
	Standard Constructor.
SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator.
template<typename IFace = IService>
SmartIF< IFace >	service (const std::string &name, bool createIf=true) const
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.
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.
Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.
StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.
StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value
	PropertyHolder ()=default
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property.
Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property.
StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation
StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property
const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties
bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name.
Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected
void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)
PropertyHolder &	operator= (const PropertyHolder &)=delete
Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor.
const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service.
MsgStream &	msgStream () const
	Return an uninitialized MsgStream.
MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts.
MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS)
MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL)
MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR)
MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR)
MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING)
MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO)
MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG)
MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE)
MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO)
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream)
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream

Private Types
typedef tbb::concurrent_bounded_queue< IAlgorithm * >	concurrentQueueIAlgPtr

Private Member Functions
StatusCode	decodeTopAlgs ()
	Decode the top Algorithm list.
StatusCode	flattenSequencer (IAlgorithm sequencer, std::list< IAlgorithm > &alglist, unsigned int recursionDepth=0)
	Recursively flatten an algList.
void	dumpInstanceMisses () const
	Dump recorded Algorithm instance misses.

Private Attributes
std::mutex	m_resource_mutex
std::map< size_t, concurrentQueueIAlgPtr * >	m_algqueue_map
std::map< size_t, size_t >	m_n_of_allowed_instances
std::map< size_t, unsigned int >	m_n_of_created_instances
std::unordered_map< std::string_view, unsigned int >	m_algInstanceMisses
	Counters for Algorithm instance misses.
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
Gaudi::Property< IAlgorithm::AlgResources_t >	m_availableResources
Gaudi::Property< int >	m_missingResourceMsgLevel
std::list< IAlgorithm * >	m_algList
	The list of all algorithms created within the Pool which are not top.
std::list< IAlgorithm * >	m_topAlgList
	The list of top algorithms.
std::list< IAlgorithm * >	m_flatUniqueAlgList
	The flat list of algorithms w/o clones.

Additional Inherited Members
Public Types inherited from extends< Service, IAlgResourcePool >
using	base_class
	Typedef to this class.
using	extend_interfaces_base
	Typedef to the base of this class.
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
	Typedef used to refer to this class from derived classes, as in.
Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using	base_class
Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids
	take union of the ext_iids of all Interfaces...
Protected Member Functions inherited from Service
std::vector< IAlgTool * > &	tools ()
	~Service () override
int	outputLevel () const
	get the `Service's` output level
Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	setUpMessaging () const override final
	Set up local caches.
MSG::Level	resetMessaging ()
	Reinitialize internal states.
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream.
Protected Attributes inherited from Service
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Service state.
Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Service state.
Gaudi::Property< int >	m_outputLevel { this, "OutputLevel", MSG::NIL, "output level" }
	flag indicating whether ToolHandle tools have been added to m_tools
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.

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

Member Typedef Documentation

◆ concurrentQueueIAlgPtr

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

private

Definition at line 60 of file AlgResourcePool.h.

Constructor & Destructor Documentation

◆ ~AlgResourcePool()

AlgResourcePool::~AlgResourcePool ( )

override

Definition at line 27 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 91 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 ( sc.isSuccess() ) {
    // Try to acquire all the resources the algorithm needs
    if ( !algo->neededResources().empty() ) {
      std::scoped_lock lock( m_resource_mutex );
 
      auto tmpResources = m_availableResources; // backup resources
      for ( const auto& [res_name, res_value] : algo->neededResources() ) {
        auto res = m_availableResources.find( res_name );
        if ( res != m_availableResources.end() && res->second >= res_value ) {
          res->second -= res_value;
        } else {
          sc             = StatusCode::FAILURE;
          const auto lvl = static_cast<MSG::Level>( m_missingResourceMsgLevel.value() );
          if ( msgLevel( lvl ) ) {
            msgStream( lvl ) << "Failure to allocate resource '" << res_name << "' for algorithm " << name
                             << " (required: " << res_value << ", available: " << res->second << ")" << endmsg;
          }
          break;
        }
      }
 
      // Could not acquire all resources
      if ( sc.isFailure() ) {
        // Restore resources
        m_availableResources = std::move( tmpResources );
 
        // 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 ); }
      }
    }
 
    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,
		unsigned int	value )

override

Acquire units of a certain resource.

Definition at line 191 of file AlgResourcePool.cpp.

                                                                                     {
  std::scoped_lock lock( m_resource_mutex );
  auto             res = m_availableResources.find( Gaudi::StringKey( name ) );
  if ( res != m_availableResources.end() && res->second >= value ) {
    res->second -= value;
    return StatusCode::SUCCESS;
  }
 
  return StatusCode::FAILURE;
}

◆ decodeTopAlgs()

StatusCode AlgResourcePool::decodeTopAlgs ( )

private

Decode the top Algorithm list.

Definition at line 249 of file AlgResourcePool.cpp.

                                          {
 
  SmartIF<IAlgManager> algMan( serviceLocator() );
  if ( !algMan.isValid() ) {
    error() << "Algorithm manager could not be properly fetched." << endmsg;
    return StatusCode::FAILURE;
  }
 
  StatusCode sc = StatusCode::SUCCESS;
 
  // Fill the top algorithm list ----
  for ( const std::string& typeName : m_topAlgNames ) {
    IAlgorithm* algo = algMan->algorithm( typeName, /*createIf*/ true ).get();
    sc               = algo->sysInitialize();
    if ( sc.isFailure() ) {
      error() << "Unable to initialize Algorithm: " << algo->name() << endmsg;
      return sc;
    }
    m_topAlgList.push_back( algo );
  }
  // Top algorithm list filled ----
 
  // Now we unroll it ----
  for ( IAlgorithm* ialgo : m_topAlgList ) { sc = flattenSequencer( ialgo, 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;
    }
  }
  ON_DEBUG {
    debug() << "List of algorithms is: " << endmsg;
    for ( IAlgorithm* algo : m_flatUniqueAlgList )
      debug() << "  o " << algo->type() << "/" << algo->name() << " @ " << algo << endmsg;
  }
 
  // Unrolled ---
 
  // Now let's manage the clones
  std::hash<std::string> hash_function;
  for ( IAlgorithm* ialgo : m_flatUniqueAlgList ) {
 
    const std::string&      item_name = ialgo->name();
    const std::string&      item_type = ialgo->type();
    size_t                  algo_id   = hash_function( item_name );
    concurrentQueueIAlgPtr* queue     = new concurrentQueueIAlgPtr();
    m_algqueue_map[algo_id]           = queue;
 
    if ( msgLevel( MSG::VERBOSE ) ) {
      verbose() << "Treating resource management and clones of " << item_name << endmsg;
    }
 
    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;
 
    // 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_MSG << "type/name to create clone of: " << item_type << "/" << item_name << endmsg;
        IAlgorithm* ialgoClone( nullptr );
 
        if ( StatusCode createAlgSc = algMan->createAlgorithm( item_type, item_name, ialgoClone, /*managed*/ true,
                                                               /*checkIfExists*/ false );
             createAlgSc.isFailure() ) {
          return createAlgSc;
        }
        ialgoClone->setIndex( i );
        queue->push( ialgoClone );
        m_n_of_created_instances[algo_id] += 1;
      }
    }
  }
 
  return sc;
}

◆ dumpInstanceMisses()

void AlgResourcePool::dumpInstanceMisses ( ) const

private

Dump recorded Algorithm instance misses.

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

                                     {
  m_topAlgList.clear();
  m_algList.clear();
  m_flatUniqueAlgList.clear();
  return extends::finalize();
}

◆ flattenSequencer()

StatusCode AlgResourcePool::flattenSequencer	(	IAlgorithm *	sequencer,
		std::list< IAlgorithm * > &	alglist,
		unsigned int	recursionDepth = 0 )

private

Recursively flatten an algList.

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

355{ return m_flatUniqueAlgList; }

◆ getTopAlgList()

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

override

Definition at line 359 of file AlgResourcePool.cpp.

359{ return m_topAlgList; }

◆ initialize()

StatusCode AlgResourcePool::initialize ( )

override

Definition at line 37 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;
 
  if ( !m_availableResources.empty() ) info() << m_availableResources << endmsg;
 
  // Check if an algorithm requests more of a resource than is available
  for ( const IAlgorithm* algo : m_flatUniqueAlgList ) {
    for ( const auto& [res_name, res_required] : algo->neededResources() ) {
      auto res           = m_availableResources.find( res_name );
      auto res_available = ( res != m_availableResources.end() ) ? res->second : 0;
      if ( res_required > res_available ) {
        error() << "Cannot satisfy resource requirement '" << res_name << "' for algorithm '" << algo->name()
                << " (required: " << res_required << ", available: " << res_available << ")" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

◆ releaseAlgorithm()

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

override

Release a certain algorithm.

Definition at line 170 of file AlgResourcePool.cpp.

                                                                                     {
 
  std::hash<std::string_view> hash_function;
  size_t                      algo_id = hash_function( name );
 
  // release resources used by the algorithm
  {
    std::scoped_lock lock( m_resource_mutex );
    for ( const auto& [res_name, res_value] : algo->neededResources() ) {
      auto res = m_availableResources.find( res_name );
      if ( res != m_availableResources.end() ) { res->second += res_value; }
    }
  }
 
  // 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,
		unsigned int	value )

override

Release a certain resource.

Definition at line 204 of file AlgResourcePool.cpp.

                                                                                     {
  std::scoped_lock lock( m_resource_mutex );
  auto             res = m_availableResources.find( Gaudi::StringKey( name ) );
  if ( res == m_availableResources.end() ) { return StatusCode::FAILURE; }
 
  res->second += value;
  return StatusCode::SUCCESS;
}

◆ start()

StatusCode AlgResourcePool::start ( )

override

Definition at line 73 of file AlgResourcePool.cpp.

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

                                 {
 
  StatusCode stopSc = Service::stop();
  if ( !stopSc.isSuccess() ) return stopSc;
 
  // sys-Stop the algorithm
  for ( IAlgorithm* 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 78 of file AlgResourcePool.h.

◆ m_algList

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

private

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

Definition at line 95 of file AlgResourcePool.h.

◆ m_algqueue_map

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

private

Definition at line 64 of file AlgResourcePool.h.

◆ m_availableResources

Gaudi::Property<IAlgorithm::AlgResources_t> AlgResourcePool::m_availableResources

private

Initial value:

{

this, "AvailableResources", {}, "Available named resources and their amounts" }

Definition at line 88 of file AlgResourcePool.h.

88 {

89 this, "AvailableResources", {}, "Available named resources and their amounts" };

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

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

◆ m_flatUniqueAlgList

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

private

The flat list of algorithms w/o clones.

Definition at line 101 of file AlgResourcePool.h.

◆ m_lazyCreation

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

private

Definition at line 80 of file AlgResourcePool.h.

80{ this, "CreateLazily", false, "" };

◆ m_missingResourceMsgLevel

Gaudi::Property<int> AlgResourcePool::m_missingResourceMsgLevel

private

Initial value:

{
      this, "MissingResourceMessageLevel", MSG::DEBUG,
      "Message level in case an algorithm cannot be schedule due to a missing resource" }

Definition at line 90 of file AlgResourcePool.h.

                                              {
      this, "MissingResourceMessageLevel", MSG::DEBUG,
      "Message level in case an algorithm cannot be schedule due to a missing resource" };

◆ m_n_of_allowed_instances

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

private

Definition at line 65 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 66 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 83 of file AlgResourcePool.h.

83 { this, "OverrideUnClonable", false,

84 "Override the un-clonability of algorithms. Use with caution!" };

◆ m_resource_mutex

std::mutex AlgResourcePool::m_resource_mutex

private

Definition at line 62 of file AlgResourcePool.h.

◆ m_topAlgList

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

private

The list of top algorithms.

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

81 {

82 this, "TopAlg", {}, "Names of the algorithms to be passed to the algorithm manager" };

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

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ concurrentQueueIAlgPtr

Constructor & Destructor Documentation

◆ ~AlgResourcePool()

Member Function Documentation

◆ acquireAlgorithm()

◆ acquireResource()

◆ decodeTopAlgs()

◆ dumpInstanceMisses()

◆ finalize()

◆ flattenSequencer()

◆ getFlatAlgList()

◆ getTopAlgList()

◆ initialize()

◆ releaseAlgorithm()

◆ releaseResource()

◆ start()

◆ stop()

Member Data Documentation

◆ m_algInstanceMisses

◆ m_algList

◆ m_algqueue_map

◆ m_availableResources

◆ m_countAlgInstMisses

◆ m_flatUniqueAlgList

◆ m_lazyCreation

◆ m_missingResourceMsgLevel

◆ m_n_of_allowed_instances

◆ m_n_of_created_instances

◆ m_overrideUnClonable

◆ m_resource_mutex

◆ m_topAlgList

◆ m_topAlgNames