The AlgorithmManager class is in charge of the creation of concrete instances of Algorithms. More...

#include </builds/gaudi/Gaudi/GaudiCoreSvc/src/ApplicationMgr/AlgorithmManager.h>

Inheritance diagram for AlgorithmManager:

[legend]

Collaboration diagram for AlgorithmManager:

[legend]

Classes
struct	AlgorithmItem

Public Types
typedef std::map< std::string, std::string, std::less<> >	AlgTypeAliasesMap
	typedefs and classes

Public Types inherited from extends< ComponentManager, IAlgManager >
using	base_class
	Typedef to this class.

using	extend_interfaces_base
	Typedef to the base of this class.

Public Types inherited from CommonMessaging< implements< IComponentManager > >
using	base_class

Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids
	take union of the ext_iids of all Interfaces...

Public Member Functions
	AlgorithmManager (IInterface *iface)
	default creator

StatusCode	addAlgorithm (IAlgorithm *alg) override
	implementation of IAlgManager::addAlgorithm

StatusCode	removeAlgorithm (IAlgorithm *alg) override
	implementation of IAlgManager::removeAlgorithm

StatusCode	createAlgorithm (const std::string &algtype, const std::string &algname, IAlgorithm *&algorithm, bool managed=false, bool checkIfExists=true) override
	implementation of IAlgManager::createAlgorithm

bool	existsAlgorithm (std::string_view name) const override
	implementation of IAlgManager::existsAlgorithm

std::vector< IAlgorithm * >	getAlgorithms () const override
	implementation of IAlgManager::getAlgorithms

StatusCode	initialize () override
	Initialization (from CONFIGURED to INITIALIZED).

StatusCode	start () override
	Start (from INITIALIZED to RUNNING).

StatusCode	stop () override
	Stop (from RUNNING to INITIALIZED).

StatusCode	finalize () override
	Finalize (from INITIALIZED to CONFIGURED).

StatusCode	reinitialize () override
	Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).

StatusCode	restart () override
	Initialization (from RUNNING to RUNNING, via INITIALIZED).

const std::string &	name () const override
	Return the name of the manager (implementation of INamedInterface)

SmartIF< IAlgorithm > &	algorithm (const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true) override

AlgTypeAliasesMap &	typeAliases ()

const AlgTypeAliasesMap &	typeAliases () const

void	outputLevelUpdate () override
	Function to call to update the outputLevel of the components (after a change in MessageSvc).

Public Member Functions inherited from extends< ComponentManager, IAlgManager >
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 ComponentManager
	ComponentManager (IInterface *application, const InterfaceID &baseIID)
	Constructor.

const InterfaceID &	componentBaseInterface () const override
	Basic interface id of the managed components.

void const *	i_cast (const InterfaceID &iid) const override
	Specialized i_cast implementation.

SmartIF< ISvcLocator > &	serviceLocator () const override

StatusCode	configure () override
	Configuration (from OFFLINE to CONFIGURED).

StatusCode	initialize () override
	Initialization (from CONFIGURED to INITIALIZED).

StatusCode	start () override
	Start (from INITIALIZED to RUNNING).

StatusCode	stop () override
	Stop (from RUNNING to INITIALIZED).

StatusCode	finalize () override
	Finalize (from INITIALIZED to CONFIGURED).

StatusCode	terminate () override
	Initialization (from CONFIGURED to OFFLINE).

StatusCode	reinitialize () override
	Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).

StatusCode	restart () override
	Initialization (from RUNNING to RUNNING, via INITIALIZED).

Gaudi::StateMachine::State	FSMState () const override
	Get the current state.

Gaudi::StateMachine::State	targetFSMState () const override
	When we are in the middle of a transition, get the state where the transition is leading us.

Public Member Functions inherited from CommonMessaging< implements< IComponentManager > >
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 Attributes
std::vector< AlgorithmItem >	m_algs
	algorithms maintained by AlgorithmManager

std::unordered_multimap< std::string, SmartIF< IAlgorithm > >	m_algsMap
	algorithms maintained by AlgorithmManager

AlgTypeAliasesMap	m_algTypeAliases

Additional Inherited Members
Protected Member Functions inherited from CommonMessaging< implements< IComponentManager > >
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 ComponentManager
SmartIF< IInterface >	m_application
	Pointer to the owner of the manager.

SmartIF< IStateful >	m_stateful
	Pointer to the IStateful interface of the owner.

InterfaceID	m_basicInterfaceId
	Basic interface id of the managed components.

SmartIF< ISvcLocator >	m_svcLocator
	Service locator (needed to access the MessageSvc)

friend	ApplicationMgr

Detailed Description

The AlgorithmManager class is in charge of the creation of concrete instances of Algorithms.

The ApplicationMgr delegates the creation and bookkeeping of algorithms to the algorithm factory. In order to be able to create algorithms from which it does not know the concrete type it requires that the algorithm has been declared in one of 3 possible ways: an abstract static creator function, a dynamic link library or an abstract factory reference.

Author: Pere Mato

Definition at line 39 of file AlgorithmManager.h.

Member Typedef Documentation

◆ AlgTypeAliasesMap

typedef std::map<std::string, std::string, std::less<> > AlgorithmManager::AlgTypeAliasesMap

typedefs and classes

Definition at line 49 of file AlgorithmManager.h.

Constructor & Destructor Documentation

◆ AlgorithmManager()

AlgorithmManager::AlgorithmManager ( IInterface * iface )

default creator

Definition at line 25 of file AlgorithmManager.cpp.

                                                            : base_class( application, IAlgorithm::interfaceID() ) {
  addRef(); // Initial count set to 1
}

Member Function Documentation

◆ addAlgorithm()

StatusCode AlgorithmManager::addAlgorithm ( IAlgorithm * alg )

override

implementation of IAlgManager::addAlgorithm

Definition at line 29 of file AlgorithmManager.cpp.

                                                           {
  m_algs.push_back( alg );
  m_algsMap.emplace( alg->name(), alg );
  return StatusCode::SUCCESS;
}

◆ algorithm()

SmartIF< IAlgorithm > & AlgorithmManager::algorithm	(	const Gaudi::Utils::TypeNameString &	typeName,
		const bool	createIf = true )

override

Definition at line 92 of file AlgorithmManager.cpp.

                                                                                                                {
  auto it = m_algsMap.find( typeName.name() );
  if ( it != m_algsMap.end() ) { // found
    return it->second;
  }
  if ( createIf ) {
    IAlgorithm* alg;
    if ( createAlgorithm( typeName.type(), typeName.name(), alg, true ).isSuccess() ) {
      return algorithm( typeName, false );
    }
  }
  return no_algorithm;
}

◆ createAlgorithm()

StatusCode AlgorithmManager::createAlgorithm	(	const std::string &	algtype,
		const std::string &	algname,
		IAlgorithm *&	algorithm,
		bool	managed = false,
		bool	checkIfExists = true )

override

implementation of IAlgManager::createAlgorithm

Definition at line 48 of file AlgorithmManager.cpp.

                                                                                                         {
  // Check if the algorithm is already existing
  if ( checkIfExists ) {
    if ( existsAlgorithm( algname ) ) {
      // return an error because an algorithm with that name already exists
      return StatusCode::FAILURE;
    }
  }
  std::string actualalgtype( algtype );
  // a '\' in front of the type name prevents alias replacement
  if ( ( actualalgtype.size() > 8 ) && ( actualalgtype.compare( 0, 8, "unalias:" ) == 0 ) ) {
    actualalgtype = actualalgtype.substr( 8 );
  } else {
    auto typeAlias = m_algTypeAliases.find( algtype );
    if ( typeAlias != m_algTypeAliases.end() ) { actualalgtype = typeAlias->second; }
  }
  algorithm = Gaudi::Algorithm::Factory::create( actualalgtype, algname, serviceLocator().get() ).release();
  if ( !algorithm ) {
    this->error() << "Algorithm of type " << actualalgtype << " is unknown (No factory available)." << endmsg;
    errno =
        0xAFFEDEAD; // code used by Gaudi for library load errors: forces getLastErrorString do use dlerror (on Linux)
    std::string err = System::getLastErrorString();
    if ( !err.empty() ) this->error() << err << endmsg;
    this->error() << "More information may be available by setting the global jobOpt \"PluginDebugLevel\" to 1"
                  << endmsg;
    return StatusCode::FAILURE;
  }
  m_algs.emplace_back( algorithm, managed );
  m_algsMap.emplace( algorithm->name(), algorithm );
  // let the algorithm know its type
  algorithm->setType( std::move( actualalgtype ) );
  StatusCode rc;
  if ( managed ) {
    // Bring the created algorithm to the target state of the ApplicationMgr
    if ( targetFSMState() >= Gaudi::StateMachine::INITIALIZED ) {
      rc = algorithm->sysInitialize();
      if ( rc.isSuccess() && targetFSMState() >= Gaudi::StateMachine::RUNNING ) { rc = algorithm->sysStart(); }
    }
    if ( !rc.isSuccess() ) { this->error() << "Failed to initialize algorithm: [" << algname << "]" << endmsg; }
  }
  return rc;
}

◆ existsAlgorithm()

bool AlgorithmManager::existsAlgorithm ( std::string_view name ) const

override

implementation of IAlgManager::existsAlgorithm

Definition at line 106 of file AlgorithmManager.cpp.

                                                                  {
  return m_algsMap.find( std::string( name ) ) != m_algsMap.end();
}

◆ finalize()

StatusCode AlgorithmManager::finalize ( )

override

Finalize (from INITIALIZED to CONFIGURED).

Definition at line 148 of file AlgorithmManager.cpp.

                                      {
  StatusCode rc;
  auto       it = m_algs.begin();
  while ( it != m_algs.end() ) { // finalize and remove from the list the managed algorithms
    if ( it->managed ) {
      auto range = m_algsMap.equal_range( it->algorithm->name() );
      auto itm = std::find_if( range.first, range.second, [&]( auto const& p ) { return p.second == it->algorithm; } );
      if ( itm == range.second ) { return StatusCode::FAILURE; }
 
      rc = it->algorithm->sysFinalize();
      if ( rc.isFailure() ) return rc;
 
      it = m_algs.erase( it );
      m_algsMap.erase( itm );
    } else {
      ++it;
    }
  }
  return rc;
}

◆ getAlgorithms()

std::vector< IAlgorithm * > AlgorithmManager::getAlgorithms ( ) const

override

implementation of IAlgManager::getAlgorithms

Definition at line 110 of file AlgorithmManager.cpp.

                                                             {
  std::vector<IAlgorithm*> listOfPtrs;
  listOfPtrs.reserve( m_algs.size() );
  std::transform( std::begin( m_algs ), std::end( m_algs ), std::back_inserter( listOfPtrs ),
                  []( const AlgorithmItem& alg ) { return alg.algorithm; } );
  return listOfPtrs;
}

◆ initialize()

StatusCode AlgorithmManager::initialize ( )

override

Initialization (from CONFIGURED to INITIALIZED).

Definition at line 118 of file AlgorithmManager.cpp.

                                        {
  StatusCode rc;
  for ( auto& it : m_algs ) {
    if ( !it.managed || it.algorithm->FSMState() >= Gaudi::StateMachine::INITIALIZED ) continue;
    rc = it.algorithm->sysInitialize();
    if ( rc.isFailure() ) return rc;
  }
  return rc;
}

◆ name()

const std::string & AlgorithmManager::name ( ) const

inlineoverride

Return the name of the manager (implementation of INamedInterface)

Definition at line 82 of file AlgorithmManager.h.

                                         {
    static const std::string _name = "AlgorithmManager";
    return _name;
  }

◆ outputLevelUpdate()

void AlgorithmManager::outputLevelUpdate ( )

override

Function to call to update the outputLevel of the components (after a change in MessageSvc).

Definition at line 204 of file AlgorithmManager.cpp.

                                         {
  resetMessaging();
  for ( auto& algItem : m_algs ) {
    const auto alg = dynamic_cast<Gaudi::Algorithm*>( algItem.algorithm );
    if ( alg ) alg->resetMessaging();
  }
}

◆ reinitialize()

StatusCode AlgorithmManager::reinitialize ( )

override

Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).

Definition at line 169 of file AlgorithmManager.cpp.

                                          {
  StatusCode rc;
  for ( auto& it : m_algs ) {
    if ( !it.managed ) continue;
    rc = it.algorithm->sysReinitialize();
    if ( rc.isFailure() ) {
      this->error() << "Unable to re-initialize algorithm: " << it.algorithm->name() << endmsg;
      return rc;
    }
  }
  return rc;
}

◆ removeAlgorithm()

StatusCode AlgorithmManager::removeAlgorithm ( IAlgorithm * alg )

override

implementation of IAlgManager::removeAlgorithm

Definition at line 35 of file AlgorithmManager.cpp.

                                                              {
  auto it = std::find( m_algs.begin(), m_algs.end(), alg );
  if ( it == m_algs.end() ) { return StatusCode::FAILURE; }
 
  auto range = m_algsMap.equal_range( alg->name() );
  auto itm   = std::find_if( range.first, range.second, [&]( auto const& p ) { return p.second == alg; } );
  if ( itm == range.second ) { return StatusCode::FAILURE; }
 
  m_algs.erase( it );
  m_algsMap.erase( itm );
  return StatusCode::SUCCESS;
}

◆ restart()

StatusCode AlgorithmManager::restart ( )

override

Initialization (from RUNNING to RUNNING, via INITIALIZED).

Definition at line 182 of file AlgorithmManager.cpp.

                                     {
  SmartIF<IAlgExecStateSvc> m_aess;
  m_aess = serviceLocator()->service( "AlgExecStateSvc" );
  if ( !m_aess.isValid() ) {
    fatal() << "Error retrieving AlgExecStateSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  StatusCode rc;
 
  for ( auto& it : m_algs ) {
    if ( !it.managed ) continue;
    rc = it.algorithm->sysRestart();
    m_aess->resetErrorCount( it.algorithm );
    if ( rc.isFailure() ) {
      this->error() << "Unable to re-initialize algorithm: " << it.algorithm->name() << endmsg;
      return rc;
    }
  }
  return rc;
}

◆ start()

StatusCode AlgorithmManager::start ( )

override

Start (from INITIALIZED to RUNNING).

Definition at line 128 of file AlgorithmManager.cpp.

                                   {
  StatusCode rc;
  for ( auto& it : m_algs ) {
    if ( !it.managed || it.algorithm->FSMState() >= Gaudi::StateMachine::RUNNING ) continue;
    rc = it.algorithm->sysStart();
    if ( rc.isFailure() ) return rc;
  }
  return rc;
}

◆ stop()

StatusCode AlgorithmManager::stop ( )

override

Stop (from RUNNING to INITIALIZED).

Definition at line 138 of file AlgorithmManager.cpp.

                                  {
  StatusCode rc;
  for ( auto& it : m_algs ) {
    if ( !it.managed ) continue;
    rc = it.algorithm->sysStop();
    if ( rc.isFailure() ) return rc;
  }
  return rc;
}

◆ typeAliases() [1/2]

AlgTypeAliasesMap & AlgorithmManager::typeAliases ( )

inline

Definition at line 89 of file AlgorithmManager.h.

89{ return m_algTypeAliases; }

◆ typeAliases() [2/2]

const AlgTypeAliasesMap & AlgorithmManager::typeAliases ( ) const

inline

Definition at line 90 of file AlgorithmManager.h.

90{ return m_algTypeAliases; }

Member Data Documentation

◆ m_algs

std::vector<AlgorithmItem> AlgorithmManager::m_algs

private

algorithms maintained by AlgorithmManager

Definition at line 96 of file AlgorithmManager.h.

◆ m_algsMap

std::unordered_multimap<std::string, SmartIF<IAlgorithm> > AlgorithmManager::m_algsMap

private

algorithms maintained by AlgorithmManager

Definition at line 97 of file AlgorithmManager.h.

◆ m_algTypeAliases

AlgTypeAliasesMap AlgorithmManager::m_algTypeAliases

private

Definition at line 100 of file AlgorithmManager.h.

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

GaudiCoreSvc/src/ApplicationMgr/AlgorithmManager.h
GaudiCoreSvc/src/ApplicationMgr/AlgorithmManager.cpp

Classes

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ AlgTypeAliasesMap

Constructor & Destructor Documentation

◆ AlgorithmManager()

Member Function Documentation

◆ addAlgorithm()

◆ algorithm()

◆ createAlgorithm()

◆ existsAlgorithm()

◆ finalize()

◆ getAlgorithms()

◆ initialize()

◆ name()

◆ outputLevelUpdate()

◆ reinitialize()

◆ removeAlgorithm()

◆ restart()

◆ start()

◆ stop()

◆ typeAliases() [1/2]

◆ typeAliases() [2/2]

Member Data Documentation

◆ m_algs

◆ m_algsMap

◆ m_algTypeAliases