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 (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) override
	Acquire a certain resource.

StatusCode	releaseResource (std::string_view name) 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 *	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.

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.

Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property.

StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name

StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string

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

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 Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name

StatusCode	getProperty (std::string_view n, std::string &v) const override
	convert the property to the string

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 (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)

bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream

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)

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

typedef boost::dynamic_bitset	state_type

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

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.

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

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

Member Typedef Documentation

◆ concurrentQueueIAlgPtr

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

private

Definition at line 62 of file AlgResourcePool.h.

◆ state_type

typedef boost::dynamic_bitset AlgResourcePool::state_type

private

Definition at line 63 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 78 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 158 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 210 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
  unsigned int           resource_counter( 0 );
  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;
 
    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_MSG << "type/name to create clone of: " << item_type << "/" << item_name << endmsg;
        IAlgorithm* ialgoClone( nullptr );
 
        StatusCode createAlgSc =
            algMan->createAlgorithm( item_type, item_name, ialgoClone, /*managed*/ true, /*checkIfExists*/ false );
 
        ialgoClone->setIndex( i );
        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 343 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 392 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 176 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 336 of file AlgResourcePool.cpp.

336{ return m_flatUniqueAlgList; }

◆ getTopAlgList()

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

override

Definition at line 340 of file AlgResourcePool.cpp.

340{ 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;
 
  // 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 141 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 167 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 60 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 374 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 84 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 96 of file AlgResourcePool.h.

◆ m_algqueue_map

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

private

Definition at line 68 of file AlgResourcePool.h.

◆ m_available_resources

state_type AlgResourcePool::m_available_resources { 0 }

private

Definition at line 67 of file AlgResourcePool.h.

67{ 0 };

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

◆ m_lazyCreation

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

private

Definition at line 86 of file AlgResourcePool.h.

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

◆ m_n_of_allowed_instances

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

private

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

89 { this, "OverrideUnClonable", false,

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

◆ m_resource_indices

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

private

Definition at line 72 of file AlgResourcePool.h.

◆ m_resource_mutex

std::mutex AlgResourcePool::m_resource_mutex

private

Definition at line 65 of file AlgResourcePool.h.

◆ m_resource_requirements

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

private

Definition at line 69 of file AlgResourcePool.h.

◆ m_topAlgList

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

private

The list of top algorithms.

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

87 {

88 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

◆ state_type

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_available_resources

◆ m_countAlgInstMisses

◆ m_flatUniqueAlgList

◆ m_lazyCreation

◆ m_n_of_allowed_instances

◆ m_n_of_created_instances

◆ m_overrideUnClonable

◆ m_resource_indices

◆ m_resource_mutex

◆ m_resource_requirements

◆ m_topAlgList

◆ m_topAlgNames