ToolSvc Class Reference

This service manages tools. More...

#include <src/ApplicationMgr/ToolSvc.h>

Inheritance diagram for ToolSvc:

Collaboration diagram for ToolSvc:

Public Member Functions
StatusCode	initialize () override
	Initialize the service. More...
StatusCode	finalize () override
	Finalize the service. More...
StatusCode	start () override
StatusCode	stop () override
StatusCode	retrieve (const std::string &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 (const std::string &tooltype, const std::string &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 (const std::string &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 (const std::string &toolname) const
	Check if the tool instance exists. More...
std::string	nameTool (const std::string &nameByUser, const IInterface *parent)
	Get Tool full name by combining nameByUser and "parent" part. More...
	ToolSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor. More...
	~ToolSvc () override=default
	Destructor. More...
void	registerObserver (IToolSvc::Observer *obs) override
void	unRegisterObserver (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...
	~extends () override=default
	Virtual destructor. 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...
StatusCode	setProperty (const Property &p) override
StatusCode	setProperty (const std::string &s) override
StatusCode	setProperty (const std::string &n, const std::string &v) override
StatusCode	getProperty (Property *p) const override
const Property &	getProperty (const std::string &name) const override
StatusCode	getProperty (const std::string &n, std::string &v) const override
const std::vector< Property * > &	getProperties () const override
bool	hasProperty (const std::string &name) const override
template<class TYPE >
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value More...
	Service (std::string name, ISvcLocator *svcloc)
	Standard Constructor. More...
SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator. More...
StatusCode	setProperties ()
	Method for setting declared properties to the values specified for the job. 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 >
Property *	declareProperty (const std::string &name, T &property, const std::string &doc="none") const
	Declare the named property. More...
Property *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="") const
	Declare remote named properties. More...
template<class T >
StatusCode	declarePrivateTool (ToolHandle< T > &handle, std::string toolTypeAndName="", bool createIf=true)
	Declare used Private tool. More...
template<class T >
StatusCode	declarePublicTool (ToolHandle< T > &handle, std::string toolTypeAndName="", bool createIf=true)
	Declare used Public tool. More...
SmartIF< IAuditorSvc > &	auditorSvc () const
	The standard auditor service.May not be invoked before sysInitialize() has been invoked. More...
Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor. More...
SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service. More...
MsgStream &	msgStream () const
	Return an uninitialized MsgStream. More...
MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts. More...
MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS) More...
MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL) More...
MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR) More...
MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR) More...
MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING) More...
MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO) More...
MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG) More...
MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE) More...
MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO) More...
MSG::Level	msgLevel () const
	get the output level from the embedded MsgStream More...
MSG::Level	outputLevel () const __attribute__((deprecated))
	Backward compatibility function for getting the output level. More...
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...
Public Member Functions inherited from extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. 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
typedef Gaudi::PluginService::Factory< IService *, const std::string &, ISvcLocator * >	Factory
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
	~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 > >
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...
Protected Attributes inherited from Service
IntegerProperty	m_outputLevel = MSG::NIL
	Service output level. More...
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Service state. More...
Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Service state. 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 23 of file ToolSvc.h.

Member Typedef Documentation

typedef std::recursive_mutex ToolSvc::CallMutex

private

Definition at line 110 of file ToolSvc.h.

Constructor & Destructor Documentation

ToolSvc::ToolSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Standard Constructor.

Parameters

name	String with service name
svc	Pointer to service locator interface

Definition at line 47 of file ToolSvc.cpp.

  : base_class( name, svc) { }

ToolSvc::~ToolSvc ( )

overridedefault

Destructor.

Member Function Documentation

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

Create Tool standard way with automatically assigned name.

Definition at line 414 of file ToolSvc.cpp.

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

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 479 of file ToolSvc.cpp.

{

  std::lock_guard<CallMutex> lock(m_mut);
  // protect against empty type
  if ( UNLIKELY(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( UNLIKELY(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 ( UNLIKELY(! 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 ) {
    StatusCode sc = mytool->setProperties();
    if ( UNLIKELY(sc.isFailure()) ) {
      error() << "Error setting properties for tool '"
              << fullname << "'" << endmsg;
      return sc;
    }
  }

  // Initialize the Tool
  StatusCode sc (StatusCode::FAILURE,true);
  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 ( UNLIKELY(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 (UNLIKELY(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;

}

bool ToolSvc::existsTool

(

const std::string &

toolname

)

const

Check if the tool instance exists.

Definition at line 653 of file ToolSvc.cpp.

{
  std::lock_guard<CallMutex> 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);
}

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 74 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 ;

}

StatusCode ToolSvc::finalizeTool ( IAlgTool *  itool ) const

private

Finalize the given tool, with exception handling.

Definition at line 663 of file ToolSvc.cpp.

{

  // Cache tool name in case of errors
  const std::string 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;

}

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

override

Get names of all tool instances of a given type.

Definition at line 351 of file ToolSvc.cpp.

{

  std::lock_guard<CallMutex> 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;
}

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

override

Get names of all tool instances.

Definition at line 363 of file ToolSvc.cpp.

{
  std::lock_guard<CallMutex> 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;
}

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

override

Get pointers to all tool instances.

Definition at line 373 of file ToolSvc.cpp.

{
  std::lock_guard<CallMutex> lock(m_mut);
  return std::vector<IAlgTool*>{std::begin(m_instancesTools),
                                std::end(m_instancesTools)};
}

StatusCode ToolSvc::initialize ( )

override

Initialize the service.

Definition at line 52 of file ToolSvc.cpp.

{

  // initialize the Service Base class
  StatusCode status = Service::initialize();
  if (UNLIKELY(status.isFailure()))
  {
    error() << "Unable to initialize the Service" << endmsg;
    return status;
  }

  // set my own (ToolSvc) properties via the jobOptionService
  if (UNLIKELY(setProperties().isFailure())) {
    error() << "Unable to set base properties" << endmsg;
    return StatusCode::FAILURE;
  }

  return status;
}

unsigned long ToolSvc::minimumToolRefCount ( ) const

private

The minimum number of refCounts of all tools.

Definition at line 710 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;
}

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

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

Definition at line 631 of file ToolSvc.cpp.

{

  if ( !parent ) { return this->name() + "." + toolname; }    // RETURN

  // check that parent has a name!
  auto named_parent = SmartIF<INamedInterface>( const_cast<IInterface*>(parent) );
  if ( named_parent )
  {
    auto fullname = named_parent->name() + "." + toolname ;
    return fullname ;                                          // RETURN
  }

  error() << "Private Tools only allowed for components implementing INamedInterface"
          << endmsg;
  //
  return "." + toolname ;
}

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

override

Definition at line 721 of file ToolSvc.cpp.

                                                    {
//------------------------------------------------------------------------------
  std::lock_guard<CallMutex> lock(m_mut);
  if ( !obs )
    throw GaudiException( "Received NULL pointer", this->name() + "::registerObserver", StatusCode::FAILURE );
  m_observers.push_back(obs);
}

StatusCode ToolSvc::releaseTool ( IAlgTool *  tool )

override

Release tool.

Definition at line 381 of file ToolSvc.cpp.

{
  std::lock_guard<CallMutex> 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;
}

StatusCode ToolSvc::retrieve ( const std::string &  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 247 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
    return retrieve ( ba::erase_tail_copy(tooltype, s_PUBLIC.size()),
                      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::npos == pos ) {
    return retrieve ( tooltype , tooltype , iid , tool , parent , createIf );
  }
  return retrieve ( tooltype.substr( 0 , pos ),
                    tooltype.substr( pos + 1 ),
                    iid , tool , parent , createIf ) ;
}

StatusCode ToolSvc::retrieve ( const std::string &  tooltype, const std::string &  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 278 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::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
    return retrieve ( tooltype , ba::erase_tail_copy(toolname, s_PUBLIC.size() ),
                      iid , tool , this , createIf ) ;
  }

  std::lock_guard<CallMutex> 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( UNLIKELY(!createIf) ) {
      warning() << "Tool " << toolname
                << " not found and creation not requested" << endmsg;
      return sc;
    }
    sc = create( tooltype, toolname, parent, itool );
    if ( sc.isFailure() ) { return sc; }
  }

  // Get the right interface of it
  sc = itool->queryInterface( iid, pp_cast<void>(&tool) );
  if( UNLIKELY(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;
}

StatusCode ToolSvc::start ( )

override

Definition at line 738 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 (UNLIKELY(!iTool->sysStart().isSuccess())) {
      fail = true;
      error() << iTool->name() << " failed to start()" << endmsg;
    }

  }

  if (UNLIKELY(fail)) {
    error() << "One or more AlgTools failed to start()" << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

StatusCode ToolSvc::stop ( )

override

Definition at line 764 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 (UNLIKELY(!iTool->sysStop().isSuccess())) {
      fail = true;
      error() << iTool->name() << " failed to stop()" << endmsg;
    }

  }

  if (UNLIKELY(fail)) {
    error() << "One or more AlgTools failed to stop()" << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

unsigned long ToolSvc::totalToolRefCount ( ) const

private

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

Definition at line 704 of file ToolSvc.cpp.

{
  return totalRefCount( m_instancesTools );
}

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

override

Definition at line 730 of file ToolSvc.cpp.

                                                      {
  std::lock_guard<CallMutex> lock(m_mut);
  auto i = std::find(m_observers.begin(),m_observers.end(),obs);
  if (i!=m_observers.end()) m_observers.erase(i);
}

Member Data Documentation

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

private

Common Tools.

Definition at line 103 of file ToolSvc.h.

CallMutex ToolSvc::m_mut

mutableprivate

Definition at line 111 of file ToolSvc.h.

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

private

Definition at line 108 of file ToolSvc.h.

IHistorySvc* ToolSvc::m_pHistorySvc = nullptr

private

Pointer to HistorySvc.

Definition at line 106 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