ServiceManager Class Reference

The ServiceManager class is in charge of the creation of concrete instances of Services. More...

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

Inheritance diagram for ServiceManager:

Collaboration diagram for ServiceManager:

Classes
struct	ServiceItem

Public Types
typedef std::list< ServiceItem >	ListSvc
typedef std::map< std::string, std::string, std::less<> >	MapType
Public Types inherited from extends< ComponentManager, ISvcManager, ISvcLocator >
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
	ServiceManager (IInterface *application)
	default creator
SmartIF< ISvcLocator > &	serviceLocator () const override
	Function needed by CommonMessaging.
	~ServiceManager () override
	virtual destructor
const std::list< IService * > &	getServices () const override
	Return the list of Services.
bool	existsService (std::string_view name) const override
	implementation of ISvcLocation::existsService
StatusCode	addService (IService *svc, int prio=DEFAULT_SVC_PRIORITY) override
	implementation of ISvcManager::addService
StatusCode	addService (const Gaudi::Utils::TypeNameString &typeName, int prio=DEFAULT_SVC_PRIORITY) override
	implementation of ISvcManager::addService
StatusCode	removeService (IService *svc) override
	implementation of ISvcManager::removeService
StatusCode	removeService (std::string_view name) override
	implementation of ISvcManager::removeService
StatusCode	declareSvcType (std::string svcname, std::string svctype) override
	implementation of ISvcManager::declareSvcType
SmartIF< IService > &	createService (const Gaudi::Utils::TypeNameString &nametype) override
	implementation of ISvcManager::createService NOTE: as this returns a &, we must guarantee that once created, these SmartIF remain pinned in their location, thus constraining the underlying implementation...
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).
int	getPriority (std::string_view name) const override
	manage priorities of services
StatusCode	setPriority (std::string_view name, int pri) override
bool	loopCheckEnabled () const override
	Get the value of the initialization loop check flag.
void	setLoopCheckEnabled (bool en) override
	Set the value of the initialization loop check flag.
const std::string &	name () const override
	Return the name of the manager (implementation of INamedInterface)
SmartIF< IService > &	service (const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true) override
	Returns a smart pointer to a service.
template<typename T>
SmartIF< T >	service (const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true)
	Returns a smart pointer to the requested interface of a service.
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, ISvcManager, ISvcLocator >
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 Member Functions
ListSvc::iterator	find (std::string_view name)
ListSvc::const_iterator	find (std::string_view name) const
ListSvc::iterator	find (const IService *ptr)
ListSvc::const_iterator	find (const IService *ptr) const
void	dump () const

Private Attributes
ListSvc	m_listsvc
	List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because there can be SmartIF<T>& 'out there' that refer to these specific SmarIF<T>, we unfortunately must guarantee that they never move after creation.
MapType	m_maptype
	Map of service name and service type.
bool	m_loopCheck = true
	Check for service initialization loops.
SmartIF< IService >	m_appSvc
	Pointer to the application IService interface.
std::list< IService * >	m_listOfPtrs
	List of pointers to the know services used to implement getServices()
GaudiUtils::Map< InterfaceID, SmartIF< IInterface > >	m_defaultImplementations
std::recursive_mutex	m_gLock
	Mutex to synchronize shared service initialization between threads.
std::map< std::string, std::recursive_mutex >	m_lockMap

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 ServiceManager class is in charge of the creation of concrete instances of Services.

The ApplicationMgr delegates the creation and bookkeeping of services to the ServiceManager. In order to be able to create services from which it is not know the concrete type it requires that the services 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 40 of file ServiceManager.h.

Member Typedef Documentation

ListSvc

typedef std::list<ServiceItem> ServiceManager::ListSvc

Definition at line 53 of file ServiceManager.h.

MapType

typedef std::map<std::string, std::string, std::less<> > ServiceManager::MapType

Definition at line 54 of file ServiceManager.h.

Constructor & Destructor Documentation

ServiceManager()

ServiceManager::ServiceManager

(

IInterface *

application

)

default creator

Definition at line 50 of file ServiceManager.cpp.

    : base_class( application, IService::interfaceID() ), m_appSvc( application ) {
  // Set the service locator to myself
  m_svcLocator = this;
  addRef(); // increase ref count, so we live forever...
}

~ServiceManager()

ServiceManager::~ServiceManager ( )

override

virtual destructor

Definition at line 57 of file ServiceManager.cpp.

                                {
  //-- inform the orphan services that I am gone....
  for ( auto& svc : m_listsvc ) svc.service->setServiceManager( nullptr );
}

Member Function Documentation

addService() [1/2]

StatusCode ServiceManager::addService ( const Gaudi::Utils::TypeNameString & typeName, int prio = DEFAULT_SVC_PRIORITY )

override

implementation of ISvcManager::addService

Definition at line 119 of file ServiceManager.cpp.

                                                                                          {
  auto it = find( typeName.name() ); // try to find the service by name
  if ( it == m_listsvc.end() ) {     // not found
    // If the service does not exist, we create it
    SmartIF<IService>& svc =
        createService( typeName ); // WARNING: svc is now a reference to something that lives in m_listsvc
    if ( !svc ) return StatusCode::FAILURE;
    it            = find( svc.get() ); // now it is in the list because createService added it
    it->priority  = prio;
    StatusCode sc = StatusCode::SUCCESS;
    if ( targetFSMState() >= Gaudi::StateMachine::INITIALIZED ) { // WARNING: this can trigger a recursion!!!
      sc = svc->sysInitialize();
      if ( sc.isSuccess() && targetFSMState() >= Gaudi::StateMachine::RUNNING ) { sc = svc->sysStart(); }
    }
    if ( sc.isFailure() ) { // if initialization failed, remove it from the list
      error() << "Unable to initialize service \"" << typeName.name() << "\"" << endmsg;
      auto lck = std::scoped_lock{ m_gLock };
      m_listsvc.erase( it );
      // Note: removing it from the list + the SmartIF going out of scope should trigger the delete
      // delete svc.get();
      return sc;
    }
    // initialization successful, we can work with the service
    // Move the just initialized service to the back of the list
    // (we care more about order of initialization than of creation)
    auto lck = std::scoped_lock{ m_gLock };
    m_listsvc.push_back( *it );
    m_listsvc.erase( it );
    it = std::prev( std::end( m_listsvc ) ); // last entry (the iterator was invalidated by erase)
  } else {
    // if the service is already known, it is equivalent to a setPriority
    it->priority = prio;
  }
  // 'it' is defined because either we found the service or we created it
  // Now we can activate the service
  it->active = true; // and make it active
  return StatusCode::SUCCESS;
}

addService() [2/2]

StatusCode ServiceManager::addService ( IService * svc, int prio = DEFAULT_SVC_PRIORITY )

override

implementation of ISvcManager::addService

Definition at line 107 of file ServiceManager.cpp.

                                                               {
  auto it  = find( svc );
  auto lck = std::scoped_lock{ m_gLock };
  if ( it != m_listsvc.end() ) {
    it->priority = prio; // if the service is already known, it is equivalent to a setPriority
    it->active   = true; // and make it active
  } else {
    m_listsvc.emplace_back( svc, prio, true );
  }
  return StatusCode::SUCCESS;
}

createService()

SmartIF< IService > & ServiceManager::createService ( const Gaudi::Utils::TypeNameString & nametype )

override

implementation of ISvcManager::createService NOTE: as this returns a &, we must guarantee that once created, these SmartIF remain pinned in their location, thus constraining the underlying implementation...

Fix-Me

: what does this mean?

Definition at line 62 of file ServiceManager.cpp.

                                                                                           {
  // Check if the service is already existing
  if ( existsService( typeName.name() ) ) {
    // return an error because a service with that name already exists
    return no_service;
  }
 
  const std::string& name = typeName.name();
  std::string        type = typeName.type();
  if ( !typeName.haveType() ) { // the type is not explicit
    // see we have some specific type mapping for the name
    auto it = m_maptype.find( typeName.name() );
    if ( it != m_maptype.end() ) {
      type = it->second; // use the declared type
    }
  }

  auto ip = type.find( "__" );
  if ( ip != std::string::npos ) type.erase( ip, type.length() );
 
  IService* service = Service::Factory::create( type, name, this ).release();
  if ( !service ) {
    fatal() << "No Service factory for " << type << " available." << endmsg;
    return no_service;
  }
  // FIXME: we used to have an invocation of isValidInterface, which implied an addRef() call
  // now that isValidInterface has been deprecated, I added a call to addRef(), but I'm not
  // sure if this is the right thing to do.
  service->addRef();
 
  if ( name == "JobOptionsSvc" ) {
    if ( !dynamic_cast<Gaudi::Interfaces::IOptionsSvc*>( service ) ) {
      fatal() << typeName << " does not implement Gaudi::Interfaces::IOptionsSvc" << endmsg;
      return no_service;
    }
  }
 
  auto lck = std::scoped_lock{ m_gLock };
  m_listsvc.push_back( service );
  service->setServiceManager( this );
  return m_listsvc.back().service; // DANGER: returns a reference to a SmartIF in m_listsvc, and hence does no longer
                                   // allow relocations of those...
}

declareSvcType()

StatusCode ServiceManager::declareSvcType ( std::string svcname, std::string svctype )

override

implementation of ISvcManager::declareSvcType

Definition at line 224 of file ServiceManager.cpp.

                                                                                {
  m_maptype.insert_or_assign( std::move( svcname ), std::move( svctype ) );
  return StatusCode::SUCCESS;
}

dump()

void ServiceManager::dump ( ) const

private

Definition at line 445 of file ServiceManager.cpp.

                                {
 
  auto& log = info();
  log << "\n"
      << "=====================  listing all services  ===================\n"
      << " prior   ref name                           active\n";
 
  for ( const auto& svc : m_listsvc ) {
 
    log.width( 6 );
    log.flags( std::ios_base::right );
    log << svc.priority << " ";
    log.width( 5 );
    log << svc.service->refCount() << " ";
    log.width( 30 );
    log.flags( std::ios_base::left );
    log << svc.service->name() << " ";
    log.width( 2 );
    log << svc.active << std::endl;
  }
 
  log << "=================================================================\n";
  log << endmsg;
}

existsService()

bool ServiceManager::existsService ( std::string_view name ) const

override

implementation of ISvcLocation::existsService

Definition at line 208 of file ServiceManager.cpp.

{ return find( name ) != m_listsvc.end(); }

finalize()

StatusCode ServiceManager::finalize ( )

override

Finalize (from INITIALIZED to CONFIGURED).

Definition at line 357 of file ServiceManager.cpp.

                                    {
  // make sure that HistogramDataSvc and THistSvc get finalized after the
  // ToolSvc, and the FileMgr after that
  int pri_tool = getPriority( "ToolSvc" );
  if ( pri_tool != 0 ) {
    setPriority( "THistSvc", pri_tool - 10 ).ignore();
    setPriority( "ChronoStatSvc", pri_tool - 20 ).ignore();
    setPriority( "AuditorSvc", pri_tool - 30 ).ignore();
    setPriority( "NTupleSvc", pri_tool - 10 ).ignore();
    setPriority( "HistogramDataSvc", pri_tool - 10 ).ignore();
    // Preserve the relative ordering between HistogramDataSvc and HistogramPersistencySvc
    setPriority( "HistogramPersistencySvc", pri_tool - 20 ).ignore();
    setPriority( "HistorySvc", pri_tool - 30 ).ignore();
    setPriority( "FileMgr", pri_tool - 40 ).ignore();
  }
 
  // get list of PostFinalize clients
  std::vector<IIncidentListener*> postFinList;
  auto                            p_inc = service<IIncidentSvc>( "IncidentSvc", false );
  if ( p_inc ) {
    p_inc->getListeners( postFinList, IncidentType::SvcPostFinalize );
    p_inc.reset();
  }
 
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // dump();
 
  StatusCode sc = StatusCode::SUCCESS;
  {
    // we work on a copy to avoid to operate twice on the services created on demand
    // which are already in the correct state.
    // only act on active services
    // call finalize() for all services in reverse order
    for ( const auto& svc : reverse( activeSvc( m_listsvc ) ) ) {
      const std::string& name = svc->name();
      // ignore the current state for the moment
      // if( Gaudi::StateMachine::INITIALIZED == svc->state() )
      DEBMSG << "Finalizing service " << name << endmsg;
      if ( !svc->sysFinalize().isSuccess() ) {
        warning() << "Finalization of service " << name << " failed" << endmsg;
        sc = StatusCode::FAILURE;
      }
    }
  }
 
  // call SvcPostFinalize on all clients
  if ( !postFinList.empty() ) {
    DEBMSG << "Will call SvcPostFinalize for " << postFinList.size() << " clients" << endmsg;
    Incident inc( "ServiceManager", IncidentType::SvcPostFinalize );
    for ( auto& itr : postFinList ) itr->handle( inc );
  }
 
  // loop over all Active Services, removing them one by one.
  // They should be deleted because the reference counting goes to 0.
  DEBMSG << "Looping over all active services..." << endmsg;
  auto it = m_listsvc.begin();
  while ( it != m_listsvc.end() ) {
    DEBMSG << "---- " << it->service->name() << " (refCount = " << it->service->refCount() << ")" << endmsg;
    if ( it->service->refCount() < 1 ) {
      warning() << "Too low reference count for " << it->service->name() << " (should not go below 1 at this point)"
                << endmsg;
      it->service->addRef();
    }
    if ( it->active ) {
      it = m_listsvc.erase( it );
    } else {
      ++it;
    }
  }
  return sc;
}

find() [1/4]

ListSvc::iterator ServiceManager::find ( const IService * ptr )

inlineprivate

Definition at line 140 of file ServiceManager.h.

                                              {
    auto lck = std::scoped_lock{ m_gLock };
    return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
  }

find() [2/4]

ListSvc::const_iterator ServiceManager::find ( const IService * ptr ) const

inlineprivate

Definition at line 144 of file ServiceManager.h.

                                                          {
    auto lck = std::scoped_lock{ m_gLock };
    return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
  }

find() [3/4]

ListSvc::iterator ServiceManager::find ( std::string_view name )

inlineprivate

Definition at line 132 of file ServiceManager.h.

                                              {
    auto lck = std::scoped_lock{ m_gLock };
    return std::find( m_listsvc.begin(), m_listsvc.end(), name );
  }

find() [4/4]

ListSvc::const_iterator ServiceManager::find ( std::string_view name ) const

inlineprivate

Definition at line 136 of file ServiceManager.h.

                                                          {
    auto lck = std::scoped_lock{ m_gLock };
    return std::find( m_listsvc.begin(), m_listsvc.end(), name );
  }

getPriority()

int ServiceManager::getPriority ( std::string_view name ) const

override

manage priorities of services

Definition at line 430 of file ServiceManager.cpp.

                                                           {
  auto it = find( name );
  return ( it != m_listsvc.end() ) ? it->priority : 0;
}

getServices()

const std::list< IService * > & ServiceManager::getServices ( ) const

override

Return the list of Services.

Definition at line 201 of file ServiceManager.cpp.

                                                            {
  m_listOfPtrs.clear();
  std::transform( std::begin( m_listsvc ), std::end( m_listsvc ), std::back_inserter( m_listOfPtrs ),
                  []( ListSvc::const_reference i ) { return i.service.get(); } );
  return m_listOfPtrs;
}

initialize()

StatusCode ServiceManager::initialize ( )

override

Initialization (from CONFIGURED to INITIALIZED).

Definition at line 229 of file ServiceManager.cpp.

                                      {
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
 
  StatusCode sc = StatusCode::SUCCESS;
  // call initialize() for all services
  for ( auto& it : activeSvc( m_listsvc ) ) {
    const std::string& name = it->name();
    switch ( it->FSMState() ) {
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Service " << name << " already initialized" << endmsg;
      break;
    case Gaudi::StateMachine::OFFLINE:
      DEBMSG << "Initializing service " << name << endmsg;
      sc = it->sysInitialize();
      if ( !sc.isSuccess() ) {
        error() << "Unable to initialize Service: " << name << endmsg;
        return sc;
      }
      break;
    default:
      error() << "Service " << name << " not in the correct state to be initialized (" << it->FSMState() << ")"
              << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

loopCheckEnabled()

bool ServiceManager::loopCheckEnabled ( ) const

override

Get the value of the initialization loop check flag.

Definition at line 442 of file ServiceManager.cpp.

{ return m_loopCheck; }

name()

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

inlineoverride

Return the name of the manager (implementation of INamedInterface)

Definition at line 114 of file ServiceManager.h.

                                         {
    static std::string _name = "ServiceManager";
    return _name;
  }

outputLevelUpdate()

void ServiceManager::outputLevelUpdate ( )

override

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

Definition at line 470 of file ServiceManager.cpp.

                                       {
  resetMessaging();
  for ( auto& svcItem : m_listsvc ) {
    const auto svc = dynamic_cast<Service*>( svcItem.service.get() );
    if ( svc ) svc->resetMessaging();
  }
}

reinitialize()

StatusCode ServiceManager::reinitialize ( )

override

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

Definition at line 321 of file ServiceManager.cpp.

                                        {
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services
  StatusCode sc = StatusCode::SUCCESS;
  // Re-Initialize all services
  for ( auto& svc : activeSvc( m_listsvc ) ) {
    sc = svc->sysReinitialize();
    if ( !sc.isSuccess() ) {
      error() << "Unable to re-initialize Service: " << svc->name() << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

removeService() [1/2]

StatusCode ServiceManager::removeService ( IService * svc )

override

implementation of ISvcManager::removeService

Definition at line 210 of file ServiceManager.cpp.

                                                        {
  auto it = find( svc );
  if ( it == m_listsvc.end() ) return StatusCode::FAILURE;
  m_listsvc.erase( it );
  return StatusCode::SUCCESS;
}

removeService() [2/2]

StatusCode ServiceManager::removeService ( std::string_view name )

override

implementation of ISvcManager::removeService

Definition at line 217 of file ServiceManager.cpp.

                                                              {
  auto it = find( name );
  if ( it == m_listsvc.end() ) return StatusCode::FAILURE;
  m_listsvc.erase( it );
  return StatusCode::SUCCESS;
}

restart()

StatusCode ServiceManager::restart ( )

override

Initialization (from RUNNING to RUNNING, via INITIALIZED).

Definition at line 339 of file ServiceManager.cpp.

                                   {
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services
  StatusCode sc = StatusCode::SUCCESS;
  // Re-Start all services
  for ( auto& svc : activeSvc( m_listsvc ) ) {
    sc = svc->sysRestart();
    if ( !sc.isSuccess() ) {
      error() << "Unable to re-start Service: " << svc->name() << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

service() [1/2]

template<typename T>

SmartIF< T > ServiceManager::service ( const Gaudi::Utils::TypeNameString & typeName, const bool createIf = true )

inline

Returns a smart pointer to the requested interface of a service.

Definition at line 124 of file ServiceManager.h.

                                                                                                    {
    return SmartIF<T>{ service( typeName, createIf ) };
  }

service() [2/2]

SmartIF< IService > & ServiceManager::service ( const Gaudi::Utils::TypeNameString & typeName, const bool createIf = true )

override

Returns a smart pointer to a service.

Definition at line 158 of file ServiceManager.cpp.

                                                                                                          {
  const std::string& name = typeName.name();
 
  // Acquire the RAII lock to avoid simultaneous attempts from different threads to initialize a service
 
  auto* imut = [&] {
    // get the global lock, then extract/create the service specific mutex
    // then release global lock
 
    auto lk  = std::scoped_lock{ this->m_gLock };
    auto mit = m_lockMap.find( name );
    if ( mit == m_lockMap.end() ) {
      mit = m_lockMap.emplace( std::piecewise_construct_t{}, std::forward_as_tuple( name ), std::forward_as_tuple() )
                .first;
    }
    return &mit->second;
  }();
 
  {
    // now we have the service specific lock on the above mutex
    auto lk2 = std::scoped_lock{ *imut };
 
    auto it = find( name );
 
    if ( it != m_listsvc.end() ) {
      if ( m_loopCheck && ( createIf && it->service->FSMState() == Gaudi::StateMachine::CONFIGURED ) ) {
        error() << "Initialization loop detected when creating service \"" << name << "\"" << endmsg;
        return no_service;
      }
      return it->service;
    }
 
    // Service not found. The user may be interested in one of the interfaces
    // of the application manager itself
    if ( name == "ApplicationMgr" || name == "APPMGR" || name == "" ) { return m_appSvc; }
 
    // last resort: we try to create the service
    if ( createIf && addService( typeName ).isSuccess() ) { return find( name )->service; }
 
    return no_service;
  }
}

serviceLocator()

SmartIF< ISvcLocator > & ServiceManager::serviceLocator ( ) const

inlineoverride

Function needed by CommonMessaging.

Definition at line 60 of file ServiceManager.h.

{ return m_svcLocator; }

setLoopCheckEnabled()

void ServiceManager::setLoopCheckEnabled ( bool en )

override

Set the value of the initialization loop check flag.

Definition at line 443 of file ServiceManager.cpp.

{ m_loopCheck = en; }

setPriority()

StatusCode ServiceManager::setPriority ( std::string_view name, int pri )

override

Definition at line 435 of file ServiceManager.cpp.

                                                                      {
  auto it = find( name );
  if ( it == m_listsvc.end() ) return StatusCode::FAILURE;
  it->priority = prio;
  return StatusCode::SUCCESS;
}

start()

StatusCode ServiceManager::start ( )

override

Start (from INITIALIZED to RUNNING).

Definition at line 260 of file ServiceManager.cpp.

                                 {
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // (which are already in the correct state.
  // only act on active services
  StatusCode sc = StatusCode::SUCCESS;
  // call initialize() for all services
  for ( auto& it : activeSvc( m_listsvc ) ) {
    const std::string& name = it->name();
    switch ( it->FSMState() ) {
    case Gaudi::StateMachine::RUNNING:
      DEBMSG << "Service " << name << " already started" << endmsg;
      break;
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Starting service " << name << endmsg;
      sc = it->sysStart();
      if ( !sc.isSuccess() ) {
        error() << "Unable to start Service: " << name << endmsg;
        return sc;
      }
      break;
    default:
      error() << "Service " << name << " not in the correct state to be started (" << it->FSMState() << ")" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

stop()

StatusCode ServiceManager::stop ( )

override

Stop (from RUNNING to INITIALIZED).

Definition at line 290 of file ServiceManager.cpp.

                                {
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services
 
  StatusCode sc = StatusCode::SUCCESS;
  // call stop() for all services
  for ( const auto& svc : reverse( activeSvc( m_listsvc ) ) ) {
    const std::string& name = svc->name();
    switch ( svc->FSMState() ) {
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Service " << name << " already stopped" << endmsg;
      break;
    case Gaudi::StateMachine::RUNNING:
      DEBMSG << "Stopping service " << name << endmsg;
      sc = svc->sysStop();
      if ( !sc.isSuccess() ) {
        error() << "Unable to stop Service: " << name << endmsg;
        return sc;
      }
      break;
    default:
      DEBMSG << "Service " << name << " not in the correct state to be stopped (" << svc->FSMState() << ")" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_appSvc

SmartIF<IService> ServiceManager::m_appSvc

private

Pointer to the application IService interface.

Definition at line 168 of file ServiceManager.h.

m_defaultImplementations

GaudiUtils::Map<InterfaceID, SmartIF<IInterface> > ServiceManager::m_defaultImplementations

private

Definition at line 173 of file ServiceManager.h.

m_gLock

std::recursive_mutex ServiceManager::m_gLock

mutableprivate

Mutex to synchronize shared service initialization between threads.

Definition at line 176 of file ServiceManager.h.

m_listOfPtrs

std::list<IService*> ServiceManager::m_listOfPtrs

mutableprivate

List of pointers to the know services used to implement getServices()

Definition at line 171 of file ServiceManager.h.

m_listsvc

ListSvc ServiceManager::m_listsvc

private

List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because there can be SmartIF<T>& 'out there' that refer to these specific SmarIF<T>, we unfortunately must guarantee that they never move after creation.

Hence, we cannot use a plain std::vector here, as that may cause relocation and/or swapping of SmartIF<T>'s, and then the already handed out references may refer to the wrong item.... Note that we could use an std::vector<std::unique_ptr<ServiceItem>> (sometimes known as 'stable vector') as then the individual ServiceItems would stay pinned in their original location, but that would put ServiceItem on the heap... And maybe I'm way too paranoid...

Definition at line 150 of file ServiceManager.h.

m_lockMap

std::map<std::string, std::recursive_mutex> ServiceManager::m_lockMap

mutableprivate

Definition at line 177 of file ServiceManager.h.

m_loopCheck

bool ServiceManager::m_loopCheck = true

private

Check for service initialization loops.

Definition at line 165 of file ServiceManager.h.

m_maptype

MapType ServiceManager::m_maptype

private

Map of service name and service type.

Definition at line 164 of file ServiceManager.h.

---

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

• GaudiCoreSvc/src/ApplicationMgr/ServiceManager.h
• GaudiCoreSvc/src/ApplicationMgr/ServiceManager.cpp