ToolSvc Class Reference

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

Inheritance diagram for ToolSvc:

Collaboration diagram for ToolSvc:

Public Member Functions
	~ToolSvc () override
	Destructor. More...
StatusCode	finalize () override
	Finalize the service. More...
StatusCode	start () override
StatusCode	stop () override
StatusCode	retrieve (std::string_view type, const InterfaceID &iid, IAlgTool *&tool, const IInterface *parent, bool createIf) override
	Retrieve tool, create it by default as common tool if it does not already exist. More...
StatusCode	retrieve (std::string_view tooltype, std::string_view toolname, const InterfaceID &iid, IAlgTool *&tool, const IInterface *parent, bool createIf) override
	Retrieve tool, create it by default as common tool if it does not already exist. More...
std::vector< std::string >	getInstances (std::string_view toolType) override
	Get names of all tool instances of a given type. More...
std::vector< std::string >	getInstances () const override
	Get names of all tool instances. More...
std::vector< IAlgTool * >	getTools () const override
	Get pointers to all tool instances. More...
StatusCode	releaseTool (IAlgTool *tool) override
	Release tool. More...
StatusCode	create (const std::string &type, const IInterface *parent, IAlgTool *&tool)
	Create Tool standard way with automatically assigned name. More...
StatusCode	create (const std::string &type, const std::string &name, const IInterface *parent, IAlgTool *&tool)
	Create Tool standard way with specified name. More...
bool	existsTool (std::string_view toolname) const
	Check if the tool instance exists. More...
std::string	nameTool (std::string_view nameByUser, const IInterface *parent)
	Get Tool full name by combining nameByUser and "parent" part. More...
void	registerObserver (IToolSvc::Observer *obs) override
Public Member Functions inherited from extends< Service, IToolSvc >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
Public Member Functions inherited from Service
const std::string &	name () const override
	Retrieve name of the service More...
StatusCode	configure () override
StatusCode	initialize () override
StatusCode	start () override
StatusCode	stop () override
StatusCode	finalize () override
StatusCode	terminate () override
Gaudi::StateMachine::State	FSMState () const override
Gaudi::StateMachine::State	targetFSMState () const override
StatusCode	reinitialize () override
StatusCode	restart () override
StatusCode	sysInitialize () override
	Initialize Service More...
StatusCode	sysStart () override
	Initialize Service More...
StatusCode	sysStop () override
	Initialize Service More...
StatusCode	sysFinalize () override
	Finalize Service More...
StatusCode	sysReinitialize () override
	Re-initialize the Service. More...
StatusCode	sysRestart () override
	Re-initialize the Service. More...
	Service (std::string name, ISvcLocator *svcloc)
	Standard Constructor More...
SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator More...
template<class T >
StatusCode	service (const std::string &name, const T *&psvc, bool createIf=true) const
	Access a service by name, creating it if it doesn't already exist. More...
template<class T >
StatusCode	service (const std::string &name, T *&psvc, bool createIf=true) const
template<typename IFace = IService>
SmartIF< IFace >	service (const std::string &name, bool createIf=true) const
template<class T >
StatusCode	service (const std::string &svcType, const std::string &svcName, T *&psvc) const
	Access a service by name and type, creating it if it doesn't already exist. More...
template<class T >
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")
template<class T >
StatusCode	declareTool (ToolHandle< T > &handle, bool createIf=true)
template<class T >
StatusCode	declareTool (ToolHandle< T > &handle, std::string toolTypeAndName, bool createIf=true)
	Declare used tool. More...
template<class T >
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandleArray< T > &hndlArr, const std::string &doc="none")
template<class T >
void	addToolsArray (ToolHandleArray< T > &hndlArr)
const std::vector< IAlgTool * > &	tools () const
SmartIF< IAuditorSvc > &	auditorSvc () const
	The standard auditor service.May not be invoked before sysInitialize() has been invoked. More...
Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
	PropertyHolder ()=default
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
	Helper to wrap a regular data member and use it as a regular property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation. More...
Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property. More...
StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name More...
StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string More...
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property. More...
virtual StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p)=0
	Set the property from a property with a different name. More...
virtual StatusCode	setProperty (const std::string &s)=0
	Set the property by string. More...
StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals. More...
StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string. More...
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value More...
StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation More...
StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property More...
const Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name More...
StatusCode	getProperty (std::string_view n, std::string &v) const override
	convert the property to the string More...
const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties More...
bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name. More...
Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected More...
void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)
	PropertyHolder (const PropertyHolder &)=delete
PropertyHolder &	operator= (const PropertyHolder &)=delete
Public Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream) More...
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...

Private Types
typedef std::recursive_mutex	CallMutex

Private Member Functions
unsigned long	totalToolRefCount () const
	The total number of refCounts on all tools in the instancesTools list. More...
unsigned long	minimumToolRefCount () const
	The minimum number of refCounts of all tools. More...
StatusCode	finalizeTool (IAlgTool *itool) const
	Finalize the given tool, with exception handling. More...

Private Attributes
std::vector< IAlgTool * >	m_instancesTools
	Common Tools. More...
IHistorySvc *	m_pHistorySvc = nullptr
	Pointer to HistorySvc. More...
std::vector< IToolSvc::Observer * >	m_observers
CallMutex	m_mut

Additional Inherited Members
Public Types inherited from extends< Service, IToolSvc >
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces... >
	Typedef to the base of this class. More...
Public Types inherited from Service
using	Factory = Gaudi::PluginService::Factory< IService *(const std::string &, ISvcLocator *)>
Public Types inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
using	PropertyHolderImpl = PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
	Typedef used to refer to this class from derived classes, as in. More...
Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using	base_class = CommonMessaging
Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids... >::type
	take union of the ext_iids of all Interfaces... More...
Protected Member Functions inherited from Service
std::vector< IAlgTool * > &	tools ()
	~Service () override
	Standard Destructor More...
int	outputLevel () const
	get the Service's output level More...
Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	setUpMessaging () const
	Set up local caches. More...
MSG::Level	resetMessaging ()
	Reinitialize internal states. More...
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...
Protected Attributes inherited from Service
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Service state More...
Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Service state More...
Gaudi::Property< int >	m_outputLevel { this, "OutputLevel", MSG::NIL, "output level" }
	flag indicating whether ToolHandle tools have been added to m_tools More...
Gaudi::Property< bool >	m_auditInit { this, "AuditServices", false, "[[deprecated]] unused" }
Gaudi::Property< bool >	m_auditorInitialize { this, "AuditInitialize", false, "trigger auditor on initialize()" }
Gaudi::Property< bool >	m_auditorStart { this, "AuditStart", false, "trigger auditor on start()" }
Gaudi::Property< bool >	m_auditorStop { this, "AuditStop", false, "trigger auditor on stop()" }
Gaudi::Property< bool >	m_auditorFinalize { this, "AuditFinalize", false, "trigger auditor on finalize()" }
Gaudi::Property< bool >	m_auditorReinitialize { this, "AuditReinitialize", false, "trigger auditor on reinitialize()" }
Gaudi::Property< bool >	m_auditorRestart { this, "AuditRestart", false, "trigger auditor on restart()" }
Gaudi::Property< bool >	m_autoRetrieveTools
Gaudi::Property< bool >	m_checkToolDeps
SmartIF< IAuditorSvc >	m_pAuditorSvc
	Auditor Service More...

Detailed Description

This service manages tools. Tools can be common, in which case a single instance can be shared by different algorithms, or private in which case it is necessary to specify the parent when requesting it. The parent of a tool can be an algortihm or a Service The environment of a tool is set by using that of the parent. A common tool is considered to belong to the ToolSvc itself.

Author

G. Corti, P. Mato

Definition at line 34 of file ToolSvc.h.

Member Typedef Documentation

CallMutex

typedef std::recursive_mutex ToolSvc::CallMutex

private

Definition at line 106 of file ToolSvc.h.

Constructor & Destructor Documentation

~ToolSvc()

ToolSvc::~ToolSvc ( )

override

Destructor.

Definition at line 56 of file ToolSvc.cpp.

                  {
  // tell the remaining observers that we're gone, and forget about unregistering..
  std::for_each( std::begin( m_observers ), std::end( m_observers ),
                 [&]( IToolSvc::Observer* obs ) { obs->setUnregister( {} ); } );
}

Member Function Documentation

create() [1/2]

StatusCode ToolSvc::create	(	const std::string &	type,
		const IInterface *	parent,
		IAlgTool *&	tool
	)

Create Tool standard way with automatically assigned name.

Definition at line 366 of file ToolSvc.cpp.

{
  const std::string& toolname = tooltype;
  return create( tooltype, toolname, parent, tool );
}

create() [2/2]

StatusCode ToolSvc::create	(	const std::string &	tooltype,
		const std::string &	toolname,
		const IInterface *	parent,
		IAlgTool *&	tool
	)

Create Tool standard way with specified name.

Now able to handle clones.

The test of tool existence is performed according to three criteria: name, type and parent. If a tool is private, i.e. the parent is not the tool Svc, and it exist but the parent is not the specified one, a clone is handed over. No clones of public tools are allowed since they would be undistinguishable.

invoke create callbacks...

Definition at line 425 of file ToolSvc.cpp.

{
 
  auto lock = std::scoped_lock{ m_mut };
  // protect against empty type
  if ( tooltype.empty() ) {
    error() << "create(): No Tool Type given" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // If parent has not been specified, assume it is the ToolSvc
  if ( !parent ) parent = this;
 
  tool = nullptr;
  // Automatically deletes the tool if not explicitly kept (i.e. on success).
  // The tool is removed from the list of known tools too.
  auto toolguard = make_toolCreateGuard( m_instancesTools );
 
  // Check if the tool already exist : this could happen with clones
  std::string fullname = nameTool( toolname, parent );
  if ( existsTool( fullname ) ) {
    // Now check if the parent is the same. This allows for clones
    for ( IAlgTool* iAlgTool : m_instancesTools ) {
      if ( iAlgTool->name() == toolname && iAlgTool->parent() == parent ) {
        // The tool exist with this name, type and parent: this is bad!
        // This excludes the possibility of cloning public tools intrinsecally
        error() << "Tool " << fullname << " already exists with the same parent" << endmsg;
        if ( parent == this )
          error() << "... In addition, the parent is the ToolSvc: public tools cannot be cloned!" << endmsg;
 
        return StatusCode::FAILURE;
      }
    }
    ON_DEBUG debug() << "Creating clone of " << fullname << endmsg;
  }
  // instantiate the tool using the factory
  try {
    toolguard.create( tooltype, fullname, parent );
    if ( !toolguard.get() ) {
      error() << "Cannot create tool " << tooltype << " (No factory found)" << endmsg;
      return StatusCode::FAILURE;
    }
  } catch ( const GaudiException& Exception ) {
    // (1) perform the printout of message
    fatal() << "Exception with tag=" << Exception.tag() << " is caught whilst instantiating tool '" << tooltype << "'"
            << endmsg;
    // (2) print  the exception itself
    // (NB!  - GaudiException is a linked list of all "previous exceptions")
    fatal() << Exception << endmsg;
    return StatusCode::FAILURE;
  } catch ( const std::exception& Exception ) {
    // (1) perform the printout of message
    fatal() << "Standard std::exception is caught whilst instantiating tool '" << tooltype << "'" << endmsg;
    // (2) print  the exception itself
    // (NB!  - GaudiException is a linked list of all "previous exceptions")
    fatal() << Exception.what() << endmsg;
    return StatusCode::FAILURE;
  } catch ( ... ) {
    // (1) perform the printout
    fatal() << "UNKNOWN Exception is caught whilst instantiating tool '" << tooltype << "'" << endmsg;
    return StatusCode::FAILURE;
  }
  ON_VERBOSE verbose() << "Created tool " << tooltype << "/" << fullname << endmsg;
 
  // Since only AlgTool has the setProperties() method it is necessary to cast
  // to downcast IAlgTool to AlgTool in order to set the properties via the JobOptions
  // service
  AlgTool* mytool = dynamic_cast<AlgTool*>( toolguard.get() );
  if ( mytool ) mytool->bindPropertiesTo( serviceLocator()->getOptsSvc() );
 
  // Initialize the Tool
  StatusCode sc = StatusCode::FAILURE;
  try {
    sc = toolguard->sysInitialize();
  }
  // Catch any exceptions
  catch ( const GaudiException& Exception ) {
    error() << "GaudiException with tag=" << Exception.tag() << " caught whilst initializing tool '" << fullname << "'"
            << endmsg << Exception << endmsg;
    return StatusCode::FAILURE;
  } catch ( const std::exception& Exception ) {
    error() << "Standard std::exception caught whilst initializing tool '" << fullname << "'" << endmsg
            << Exception.what() << endmsg;
    return StatusCode::FAILURE;
  } catch ( ... ) {
    error() << "UNKNOWN Exception caught whilst initializing tool '" << fullname << "'" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Status of tool initialization
  if ( sc.isFailure() ) {
    error() << "Error initializing tool '" << fullname << "'" << endmsg;
    return sc;
  }
 
  // Start the tool if we are running.
  if ( m_state == Gaudi::StateMachine::RUNNING ) {
    sc = toolguard->sysStart();
 
    if ( sc.isFailure() ) {
      error() << "Error starting tool '" << fullname << "'" << endmsg;
      return sc;
    }
  }
 
  // The tool has been successfully created and initialized,
  // so we inform the guard that it can release it
  tool = toolguard.release();
 
  std::for_each( m_observers.begin(), m_observers.end(), [&]( IToolSvc::Observer* obs ) { obs->onCreate( tool ); } );
  // TODO: replace by generic callback
  // Register the tool with the HistorySvc
  if ( m_pHistorySvc || service( "HistorySvc", m_pHistorySvc, false ).isSuccess() ) {
    m_pHistorySvc->registerAlgTool( *tool ).ignore();
  }
  return StatusCode::SUCCESS;
}

existsTool()

bool ToolSvc::existsTool

(

std::string_view

toolname

)

const

Check if the tool instance exists.

Definition at line 568 of file ToolSvc.cpp.

{
  auto lock = std::scoped_lock{ m_mut };
  auto i    = std::find_if( std::begin( m_instancesTools ), std::end( m_instancesTools ),
                            [&]( const IAlgTool* tool ) { return tool->name() == fullname; } );
  return i != std::end( m_instancesTools );
}

finalize()

StatusCode ToolSvc::finalize ( )

override

Finalize the service.

Algorithm: 2 passes. First pass:

• do not explicitly release any tools
• finalize tools, in the order of increasing number of refCounts Second pass:
• explicitly release all tools, one release() on all tools per loop. -> tools are deleted in the order of increasing number of refCounts.

Inner loop: full loop over all left-over tools

• finalize tools with the minimum number of refCounts in the list.
• Remove finalized tools from list of tools, and add them to the list of finalized tools, to be deleted at the end. This way, any non-finalized tools who still reference already finalized tools in their finalize() will still find a live tool. Outer loop: keep on going until nothing changes in the list of tools. Checking for:
• number of left-over tools
• total number of refcounts
• minimum number of refcounts

Definition at line 63 of file ToolSvc.cpp.

{
  // Finalize and delete all left-over tools. Normally all tools created with
  // ToolSvc are left over, since ToolSvc holds a refCount (via AlgTool ctor).
  // Several cases need to be covered:
  // 1) Simple dependencies: no circular dependencies between tools,
  //    and tools not using other tools
  // 2) Tools-using-tools (but no circular dependencies)
  //   a) release() is called in the tool::finalize() (e.g. via GaudiAlgorithm)
  //   b) release() is called in the tool destructor  (e.g. via ToolHandle)
  // 3) Circular dependencies between tools
  //   a) release() is called in the tool::finalize() (e.g. via GaudiAlgorithm)
  //   b) release() is called in the tool destructor  (e.g. via ToolHandle)
  // 4) In addition to each of the above cases, refCounting of a particular tool
  //    might not have been done correctly in the code. Typically release()
  //    is not called, so we are left with a too high refCount.
  //    What to do with those, and how to avoid a crash while handling them...
 
  info() << "Removing all tools created by ToolSvc" << endmsg;
 
  // Print out list of tools
  ON_DEBUG {
    auto& log = debug();
    log << "  Tool List : ";
    for ( const auto& iTool : m_instancesTools ) { log << iTool->name() << ":" << iTool->refCount() << " "; }
    log << endmsg;
  }
 
  //
  // first pass: Finalize all tools (but don't delete them)
  //
  boost::circular_buffer<IAlgTool*> finalizedTools( m_instancesTools.size() ); // list of tools that have been finalized
  bool                              fail( false );
  size_t                            toolCount        = m_instancesTools.size();
  unsigned long                     startRefCount    = 0;
  unsigned long                     endRefCount      = totalToolRefCount();
  unsigned long                     startMinRefCount = 0;
  unsigned long                     endMinRefCount   = minimumToolRefCount();
  while ( toolCount > 0 && endRefCount > 0 && ( endRefCount != startRefCount || endMinRefCount != startMinRefCount ) ) {
    ON_DEBUG if ( endMinRefCount != startMinRefCount ) {
      debug() << toolCount << " tools left to finalize. Summed refCounts: " << endRefCount << endmsg;
      debug() << "Will finalize tools with refCount <= " << endMinRefCount << endmsg;
    }
    startMinRefCount      = endMinRefCount;
    startRefCount         = endRefCount;
    unsigned long maxLoop = toolCount + 1;
    while ( --maxLoop > 0 && !m_instancesTools.empty() ) {
      IAlgTool* pTool = m_instancesTools.back();
      // removing tool from list makes ToolSvc::releaseTool( IAlgTool* ) a noop
      m_instancesTools.pop_back();
      unsigned long count = pTool->refCount();
      // cache tool name
      const std::string& toolName = pTool->name();
      if ( count <= startMinRefCount ) {
        ON_DEBUG debug() << "  Performing finalization of " << toolName << " (refCount " << count << ")" << endmsg;
        // finalize of one tool may trigger a release of another tool
        //   pTool->sysFinalize().ignore();
        if ( !finalizeTool( pTool ).isSuccess() ) {
          warning() << "    FAILURE finalizing " << toolName << endmsg;
          fail = true;
        }
        // postpone deletion
        finalizedTools.push_back( pTool );
      } else {
        // Place back at the front of the list to try again later
        // ToolSvc::releaseTool( IAlgTool* ) remains active for this tool
        ON_DEBUG debug() << "  Delaying   finalization of " << toolName << " (refCount " << count << ")" << endmsg;
        m_instancesTools.insert( std::begin( m_instancesTools ), pTool );
      }
    } // end of inner loop
    toolCount      = m_instancesTools.size();
    endRefCount    = totalToolRefCount();
    endMinRefCount = minimumToolRefCount();
  }; // end of outer loop
 
  //
  // Second pass: Delete all finalized tools
  //
  // Delete in the order of increasing number of refCounts.
  // Loop over tools in the same order as the order in which they were finalized.
  // All tools in the list of finalized tools are no longer in the instancesTools list.
  // If a tool destructor calls releaseTool() on another tool, this will have no
  // effect on the 'other tool' if this 'other tool' is in the list of finalized tools.
  // If this 'other tool' is still in the instancesTools list, it may trigger finalization
  // (in releaseTool()), deletion and removal from the instancesTools list.
  // Therefore, the check on non-finalised tools should happen *after* the deletion
  // of the finalized tools.
  ON_DEBUG debug() << "Deleting " << finalizedTools.size() << " finalized tools" << endmsg;
  auto     maxLoop = totalRefCount( finalizedTools ) + 1;
  while ( --maxLoop > 0 && !finalizedTools.empty() ) {
    IAlgTool* pTool = finalizedTools.front();
    finalizedTools.pop_front();
    auto count = pTool->refCount();
    if ( count == 1 ) {
      ON_DEBUG debug() << "  Performing deletion of " << pTool->name() << endmsg;
    } else {
      ON_VERBOSE verbose() << "  Delaying   deletion of " << pTool->name() << " (refCount " << count << ")" << endmsg;
      // Move to the end when refCount still not zero
      finalizedTools.push_back( pTool );
    }
    // do a forced release
    pTool->release();
  }
 
  // Error if by now not all tools are properly finalised
  if ( !m_instancesTools.empty() ) {
    error() << "Unable to finalize and delete the following tools : ";
    for ( const auto& iTool : m_instancesTools ) { error() << iTool->name() << ": " << iTool->refCount() << " "; }
    error() << endmsg;
  }
 
  // by now, all tools should be deleted and removed.
  if ( !finalizedTools.empty() ) {
    error() << "Failed to delete the following " << finalizedTools.size()
            << " finalized tools. Bug in ToolSvc::finalize()?: ";
    for ( const auto& iTool : finalizedTools ) { error() << iTool->name() << ": " << iTool->refCount() << " "; }
    error() << endmsg;
  }
 
  if ( m_pHistorySvc ) m_pHistorySvc->release();
 
  // Finalize this specific service
  return ( Service::finalize().isSuccess() && !fail ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
}

finalizeTool()

StatusCode ToolSvc::finalizeTool ( IAlgTool *  itool ) const

private

Finalize the given tool, with exception handling.

Definition at line 578 of file ToolSvc.cpp.

{
 
  // Cache tool name in case of errors
  const auto& toolName = itool->name();
  StatusCode  sc;
 
  // Finalise the tool inside a try block
  try {
    sc = itool->sysFinalize();
  }
  // Catch any exceptions
  catch ( const GaudiException& Exception ) {
    error() << "GaudiException with tag=" << Exception.tag() << " caught whilst finalizing tool '" << toolName << "'"
            << endmsg << Exception << endmsg;
    sc = StatusCode::FAILURE;
  } catch ( const std::exception& Exception ) {
    error() << "Standard std::exception caught whilst finalizing tool '" << toolName << "'" << endmsg
            << Exception.what() << endmsg;
    sc = StatusCode::FAILURE;
  } catch ( ... ) {
    error() << "UNKNOWN Exception caught whilst finalizing tool '" << toolName << "'" << endmsg;
    sc = StatusCode::FAILURE;
  }
 
  return sc;
}

getInstances() [1/2]

std::vector< std::string > ToolSvc::getInstances ( ) const

override

Get names of all tool instances.

Definition at line 319 of file ToolSvc.cpp.

{
  auto                     lock = std::scoped_lock{ m_mut };
  std::vector<std::string> tools{ m_instancesTools.size() };
  std::transform( std::begin( m_instancesTools ), std::end( m_instancesTools ), std::begin( tools ),
                  []( const IAlgTool* t ) { return t->name(); } );
  return tools;
}

getInstances() [2/2]

std::vector< std::string > ToolSvc::getInstances ( std::string_view  toolType )

override

Get names of all tool instances of a given type.

Definition at line 307 of file ToolSvc.cpp.

{
 
  auto                     lock = std::scoped_lock{ m_mut };
  std::vector<std::string> tools;
  for ( const auto& tool : m_instancesTools ) {
    if ( tool->type() == toolType ) tools.push_back( tool->name() );
  }
  return tools;
}

getTools()

std::vector< IAlgTool * > ToolSvc::getTools ( ) const

override

Get pointers to all tool instances.

Definition at line 329 of file ToolSvc.cpp.

{
  auto lock = std::scoped_lock{ m_mut };
  return std::vector<IAlgTool*>{ std::begin( m_instancesTools ), std::end( m_instancesTools ) };
}

minimumToolRefCount()

unsigned long ToolSvc::minimumToolRefCount ( ) const

private

The minimum number of refCounts of all tools.

Definition at line 614 of file ToolSvc.cpp.

{
  auto i =
      std::min_element( std::begin( m_instancesTools ), std::end( m_instancesTools ),
                        []( const IAlgTool* lhs, const IAlgTool* rhs ) { return lhs->refCount() < rhs->refCount(); } );
  return i != std::end( m_instancesTools ) ? ( *i )->refCount() : 0;
}

nameTool()

std::string ToolSvc::nameTool	(	std::string_view	nameByUser,
		const IInterface *	parent
	)

Get Tool full name by combining nameByUser and "parent" part.

Definition at line 549 of file ToolSvc.cpp.

{
 
  if ( !parent ) { return std::string{ this->name() }.append( "." ).append( toolname ); } // RETURN
 
  // check that parent has a name!
  auto named_parent = SmartIF<INamedInterface>( const_cast<IInterface*>( parent ) );
  if ( named_parent ) {
    auto fullname = std::string{ named_parent->name() }.append( "." ).append( toolname );
    return fullname; // RETURN
  }
 
  error() << "Private Tools only allowed for components implementing INamedInterface" << endmsg;
  //
  return std::string{ "." }.append( toolname );
}

registerObserver()

void ToolSvc::registerObserver ( IToolSvc::Observer *  obs )

override

Definition at line 624 of file ToolSvc.cpp.

                                                      {
  //------------------------------------------------------------------------------
  if ( !obs ) throw GaudiException( "Received NULL pointer", this->name() + "::registerObserver", StatusCode::FAILURE );
 
  auto lock = std::scoped_lock{ m_mut };
  obs->setUnregister( [this, obs]() {
    auto lock = std::scoped_lock{ m_mut };
    auto i    = std::find( m_observers.begin(), m_observers.end(), obs );
    if ( i != m_observers.end() ) m_observers.erase( i );
  } );
  m_observers.push_back( obs );
}

releaseTool()

StatusCode ToolSvc::releaseTool ( IAlgTool *  tool )

override

Release tool.

Definition at line 336 of file ToolSvc.cpp.

{
  auto       lock = std::scoped_lock{ m_mut };
  StatusCode sc( StatusCode::SUCCESS );
  // test if tool is in known list (protect trying to access a previously deleted tool)
  if ( m_instancesTools.rend() != std::find( m_instancesTools.rbegin(), m_instancesTools.rend(), tool ) ) {
    unsigned long count = tool->refCount();
    if ( count == 1 ) {
      // finalize the tool
 
      if ( Gaudi::StateMachine::OFFLINE == m_targetState ) {
        // We are being called during ToolSvc::finalize()
        // message format matches the one in ToolSvc::finalize()
        debug() << "  Performing finalization of " << tool->name() << " (refCount " << count << ")" << endmsg;
        // message format matches the one in ToolSvc::finalize()
        debug() << "  Performing     deletion of " << tool->name() << endmsg;
      } else {
        debug() << "Performing finalization and deletion of " << tool->name() << endmsg;
      }
      sc = finalizeTool( tool );
      // remove from known tools...
      remove( m_instancesTools, tool );
    }
    tool->release();
  }
  return sc;
}

retrieve() [1/2]

StatusCode ToolSvc::retrieve ( std::string_view  tooltype, std::string_view  toolname, const InterfaceID &  iid, IAlgTool *&  tool, const IInterface *  parent, bool  createIf  )

override

Retrieve tool, create it by default as common tool if it does not already exist.

invoke retrieve callbacks...

Definition at line 243 of file ToolSvc.cpp.

{
  // check the applicability of another method:
  // ignore the provided name if it is empty or the type contains a name
  if ( toolname.empty() || ( std::string_view::npos != tooltype.find( '/' ) ) ) {
    return retrieve( tooltype, iid, tool, parent, createIf );
  }
 
  // check for tools, which by name are required to be public:
  if ( ba::ends_with( toolname, s_PUBLIC ) ) {
    // parent for PUBLIC tool is this, i.e. ToolSvc
    toolname.remove_suffix( s_PUBLIC.size() );
    return retrieve( tooltype, toolname, iid, tool, this, createIf );
  }
 
  auto lock = std::scoped_lock{ m_mut };
 
  IAlgTool*  itool = nullptr;
  StatusCode sc( StatusCode::FAILURE );
 
  tool = nullptr;
 
  // If parent is not specified it means it is the ToolSvc itself
  if ( !parent ) parent = this;
  const std::string fullname = nameTool( toolname, parent );
 
  // Find tool in list of those already existing, and tell its
  // interface that it has been used one more time
  auto it = std::find_if( std::begin( m_instancesTools ), std::end( m_instancesTools ),
                          [&]( const IAlgTool* i ) { return i->name() == fullname && i->parent() == parent; } );
  if ( it != std::end( m_instancesTools ) ) {
    ON_DEBUG debug() << "Retrieved tool " << toolname << " with parent " << parent << endmsg;
    itool = *it;
  }
 
  if ( !itool ) {
    // Instances of this tool do not exist, create an instance if desired
    // otherwise return failure
    if ( !createIf ) {
      warning() << "Tool " << toolname << " not found and creation not requested" << endmsg;
      return sc;
    }
    sc = create( std::string{ tooltype }, std::string{ toolname }, parent, itool );
    if ( sc.isFailure() ) { return sc; }
  }
 
  // Get the right interface of it
  sc = itool->queryInterface( iid, pp_cast<void>( &tool ) );
  if ( sc.isFailure() ) {
    error() << "Tool " << toolname << " either does not implement the correct interface, or its version is incompatible"
            << endmsg;
    return sc;
  }
 
  std::for_each( std::begin( m_observers ), std::end( m_observers ),
                 [&]( IToolSvc::Observer* obs ) { obs->onRetrieve( itool ); } );
  return sc;
}

retrieve() [2/2]

StatusCode ToolSvc::retrieve ( std::string_view  type, const InterfaceID &  iid, IAlgTool *&  tool, const IInterface *  parent, bool  createIf  )

override

Retrieve tool, create it by default as common tool if it does not already exist.

Definition at line 219 of file ToolSvc.cpp.

{
  // check for tools, which by name are required to be public:
  if ( ba::ends_with( tooltype, s_PUBLIC ) ) {
    // parent for PUBLIC tool is 'this', i.e. ToolSvc
    tooltype.remove_suffix( s_PUBLIC.size() );
    return retrieve( tooltype, iid, tool, this, createIf );
  }
 
  // protect against empty type
  if ( tooltype.empty() ) {
    error() << "retrieve(): No Tool Type/Name given" << endmsg;
    return StatusCode::FAILURE;
  }
  auto pos = tooltype.find( '/' );
  if ( std::string_view::npos == pos ) { return retrieve( tooltype, tooltype, iid, tool, parent, createIf ); }
  return retrieve( tooltype.substr( 0, pos ), tooltype.substr( pos + 1 ), iid, tool, parent, createIf );
}

start()

StatusCode ToolSvc::start ( )

override

Definition at line 638 of file ToolSvc.cpp.

{
 
  ON_DEBUG debug() << "START transition for AlgTools" << endmsg;
 
  bool fail( false );
  for ( auto& iTool : m_instancesTools ) {
    ON_VERBOSE verbose() << iTool->name() << "::start()" << endmsg;
 
    if ( !iTool->sysStart().isSuccess() ) {
      fail = true;
      error() << iTool->name() << " failed to start()" << endmsg;
    }
  }
 
  if ( fail ) {
    error() << "One or more AlgTools failed to start()" << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

stop()

StatusCode ToolSvc::stop ( )

override

Definition at line 662 of file ToolSvc.cpp.

{
 
  ON_DEBUG debug() << "STOP transition for AlgTools" << endmsg;
 
  bool fail( false );
  for ( auto& iTool : m_instancesTools ) {
    ON_VERBOSE verbose() << iTool->name() << "::stop()" << endmsg;
 
    if ( !iTool->sysStop().isSuccess() ) {
      fail = true;
      error() << iTool->name() << " failed to stop()" << endmsg;
    }
  }
 
  if ( fail ) {
    error() << "One or more AlgTools failed to stop()" << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

totalToolRefCount()

unsigned long ToolSvc::totalToolRefCount ( ) const

private

The total number of refCounts on all tools in the instancesTools list.

Definition at line 608 of file ToolSvc.cpp.

{
  return totalRefCount( m_instancesTools );
}

Member Data Documentation

m_instancesTools

std::vector<IAlgTool*> ToolSvc::m_instancesTools

private

Common Tools.

Definition at line 99 of file ToolSvc.h.

m_mut

CallMutex ToolSvc::m_mut

mutableprivate

Definition at line 107 of file ToolSvc.h.

m_observers

std::vector<IToolSvc::Observer*> ToolSvc::m_observers

private

Definition at line 104 of file ToolSvc.h.

m_pHistorySvc

IHistorySvc* ToolSvc::m_pHistorySvc = nullptr

private

Pointer to HistorySvc.

Definition at line 102 of file ToolSvc.h.

---

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

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