Default implementation of the IIncidentSvc interface. More...

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

Inheritance diagram for IncidentSvc:

[legend]

Collaboration diagram for IncidentSvc:

[legend]

Public Member Functions
StatusCode	finalize () override

void	addListener (IIncidentListener *lis, const std::string &type="", long priority=0, bool rethrow=false, bool singleShot=false) override

void	removeListener (IIncidentListener *l, const std::string &type="") override

void	fireIncident (const Incident &incident) override

void	fireIncident (std::unique_ptr< Incident > incident) override

void	getListeners (std::vector< IIncidentListener * > &lis, const std::string &type="") const override

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

	~IncidentSvc () override

IIncidentSvc::IncidentPack	getIncidents (const EventContext *ctx) override

Public Member Functions inherited from extends< Service, IIncidentSvc >
void const *	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<typename IFace = IService>
SmartIF< IFace >	service (const std::string &name, bool createIf=true) const

template<class T >
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")

template<class T >
StatusCode	declareTool (ToolHandle< T > &handle, bool createIf=true)

template<class T >
StatusCode	declareTool (ToolHandle< T > &handle, const std::string &toolTypeAndName, bool createIf=true)
	Declare used tool. 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, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation. More...

	requires (!Gaudi::Details::is_gaudi_property_v< TYPE >) Gaudi
	Helper to wrap a regular data member and use it as a regular property. 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	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::list< IIncidentSvc::Listener >	ListenerList

typedef GaudiUtils::HashMap< Gaudi::StringKey, std::unique_ptr< ListenerList > >	ListenerMap

typedef tbb::concurrent_queue< std::unique_ptr< Incident > >	IncQueue_t

Private Member Functions
ListenerMap::iterator	removeListenerFromList (ListenerMap::iterator, IIncidentListener *item, bool scheduleRemoval)

void	i_fireIncident (const Incident &incident, const std::string &type)
	Internal function to allow incidents listening to all events. More...

Private Attributes
ListenerMap	m_listenerMap
	List of auditor names. More...

const std::string *	m_currentIncidentType = nullptr
	Incident being fired. More...

std::recursive_mutex	m_listenerMapMutex
	Mutex to synchronize access to m_listenerMap. More...

ChronoEntity	m_timer
	timer & it's lock More...

bool	m_timerLock = false

tbb::concurrent_unordered_map< EventContext::ContextID_t, IncQueue_t >	m_firedIncidents

tbb::concurrent_unordered_map< EventContext::ContextID_t, EventContext::ContextEvt_t >	m_slotEvent
	Event ID for each slot. More...

Additional Inherited Members
Public Types inherited from extends< Service, IIncidentSvc >
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

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_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

Default implementation of the IIncidentSvc interface.

This implementation is thread-safe with the following features:

Calls to fireIncident(), addListener() and removeListener() are synchronized across threads.
Calls to IIncidentListener::handle() are serialized, i.e. at any time there is at most one incident handler being executed across all threads.

Definition at line 35 of file IncidentSvc.h.

Member Typedef Documentation

◆ IncQueue_t

typedef tbb::concurrent_queue<std::unique_ptr<Incident> > IncidentSvc::IncQueue_t

private

Definition at line 80 of file IncidentSvc.h.

◆ ListenerList

typedef std::list<IIncidentSvc::Listener> IncidentSvc::ListenerList

private

Definition at line 40 of file IncidentSvc.h.

◆ ListenerMap

typedef GaudiUtils::HashMap<Gaudi::StringKey, std::unique_ptr<ListenerList> > IncidentSvc::ListenerMap

private

Definition at line 41 of file IncidentSvc.h.

Constructor & Destructor Documentation

◆ IncidentSvc()

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

Definition at line 44 of file IncidentSvc.cpp.

44 : base_class( name, svc ) {}

◆ ~IncidentSvc()

IncidentSvc::~IncidentSvc ( )

override

Definition at line 45 of file IncidentSvc.cpp.

45 { auto lock = std::scoped_lock{ m_listenerMapMutex }; }

Member Function Documentation

◆ addListener()

void IncidentSvc::addListener	(	IIncidentListener *	lis,
		const std::string &	type = `""`,
		long	priority = `0`,
		bool	rethrow = `false`,
		bool	singleShot = `false`
	)

override

Definition at line 55 of file IncidentSvc.cpp.

                                                  {
   static const std::string all{ "ALL" };
   auto                     lock = std::scoped_lock{ m_listenerMapMutex };
  
   const std::string& ltype = ( !type.empty() ? type : all );
  
   // find if the type already exists
   auto itMap = m_listenerMap.find( ltype );
   if ( itMap == m_listenerMap.end() ) {
     // if not found, create and insert now a list of listeners
     auto p = m_listenerMap.insert( { ltype, std::make_unique<ListenerList>() } );
     if ( !p.second ) { /* OOPS */
     }
     itMap = p.first;
   }
   auto& llist = *itMap->second;
   // add Listener ordered by priority -- higher priority first,
   // and then add behind listeneres with the same priority
   // -- so we skip over all items with higher or same priority
   auto i = std::partition_point( std::begin( llist ), std::end( llist ),
                                  [&]( const Listener& j ) { return j.priority >= prio; } );
   // We insert before the current position
   DEBMSG << "Adding [" << type << "] listener '" << getListenerName( lis ) << "' with priority " << prio << endmsg;
   llist.emplace( i, IIncidentSvc::Listener{ lis, prio, rethrow, singleShot } );
 }

◆ finalize()

StatusCode IncidentSvc::finalize ( )

override

Definition at line 46 of file IncidentSvc.cpp.

                                  {
   DEBMSG << m_timer.outputUserTime( "Incident  timing: Mean(+-rms)/Min/Max:%3%(+-%4%)/%6%/%7%[ms] ", System::milliSec )
          << m_timer.outputUserTime( "Total:%2%[s]", System::Sec ) << endmsg;
  
   m_firedIncidents.clear();
  
   // Finalize this specific service
   return Service::finalize();
 }

◆ fireIncident() [1/2]

void IncidentSvc::fireIncident ( const Incident & incident )

override

Definition at line 190 of file IncidentSvc.cpp.

                                                          {
  
   Gaudi::Utils::LockedChrono timer( m_timer, m_timerLock );
  
   // Call specific listeners
   i_fireIncident( incident, incident.type() );
   // Try listeners registered for ALL incidents
   if ( incident.type() != "ALL" ) { // avoid double calls if somebody fires the incident "ALL"
     i_fireIncident( incident, "ALL" );
   }
 }

◆ fireIncident() [2/2]

void IncidentSvc::fireIncident ( std::unique_ptr< Incident > incident )

override

Definition at line 201 of file IncidentSvc.cpp.

                                                                  {
  
   const EventContext& ctx = incident->context();
   DEBMSG << "Async incident '" << incident->type() << "' fired on context " << ctx << endmsg;
  
   // create or get incident queue for slot
   auto [incItr, inserted1] = m_firedIncidents.insert( { ctx.slot(), IncQueue_t() } );
   // save or get current event for slot
   auto [slotItr, inserted2] = m_slotEvent.insert( { ctx.slot(), ctx.evt() } );
  
   // if new event in slot, clear all remaining old incidents
   if ( slotItr->second != ctx.evt() ) {
     slotItr->second = ctx.evt();
  
     if ( msgLevel( MSG::DEBUG ) and !incItr->second.empty() ) {
       debug() << "Clearing remaining obsolete incidents from slot " << ctx.slot() << ":";
       std::unique_ptr<Incident> inc;
       while ( incItr->second.try_pop( inc ) ) { debug() << " " << inc->type() << "(" << inc->context() << ")"; }
       debug() << endmsg;
     }
     incItr->second.clear();
   }
   incItr->second.push( std::move( incident ) );
 }

◆ getIncidents()

IIncidentSvc::IncidentPack IncidentSvc::getIncidents ( const EventContext * ctx )

override

Definition at line 241 of file IncidentSvc.cpp.

                                                                             {
   IIncidentSvc::IncidentPack p;
   if ( ctx ) {
     auto incs = m_firedIncidents.find( ctx->slot() );
     if ( incs != m_firedIncidents.end() ) {
       std::unique_ptr<Incident> inc;
  
       DEBMSG << "Collecting listeners fired on context " << *ctx << endmsg;
       while ( incs->second.try_pop( inc ) ) {
         // ensure incident is for this event (should not be necessary)
         if ( inc->context().evt() == ctx->evt() ) {
           std::scoped_lock lock( m_listenerMapMutex );
           auto             i = m_listenerMap.find( inc->type() );
           if ( i != m_listenerMap.end() ) {
             p.emplace_back( std::move( inc ), std::vector<Listener>{ i->second->begin(), i->second->end() } );
           }
         }
       }
     }
   }
   return p;
 }

◆ getListeners()

void IncidentSvc::getListeners	(	std::vector< IIncidentListener * > &	lis,
		const std::string &	type = `""`
	)		const

override

Definition at line 226 of file IncidentSvc.cpp.

                                                                                               {
   static const std::string ALL{ "ALL" };
   auto                     lock = std::scoped_lock{ m_listenerMapMutex };
  
   const std::string& ltype = ( !type.empty() ? type : ALL );
  
   l.clear();
   auto i = m_listenerMap.find( ltype );
   if ( i != m_listenerMap.end() ) {
     l.reserve( i->second->size() );
     std::transform( std::begin( *i->second ), std::end( *i->second ), std::back_inserter( l ),
                     []( const Listener& j ) { return j.iListener; } );
   }
 }

◆ i_fireIncident()

void IncidentSvc::i_fireIncident	(	const Incident &	incident,
		const std::string &	type
	)

private

Internal function to allow incidents listening to all events.

Definition at line 117 of file IncidentSvc.cpp.

                                                                                           {
  
   auto lock = std::scoped_lock{ m_listenerMapMutex };
  
   // Wouldn't it be better to write a small 'ReturnCode' service which
   // looks for these 'special' incidents and does whatever needs to
   // be done instead of making a special case here?
  
   // Special case: FailInputFile incident must set the application return code
   if ( incident.type() == IncidentType::FailInputFile || incident.type() == IncidentType::CorruptedInputFile ) {
     auto appmgr = serviceLocator()->as<IProperty>();
     Gaudi::setAppReturnCode( appmgr, incident.type() == IncidentType::FailInputFile
                                          ? Gaudi::ReturnCode::FailInput
                                          : Gaudi::ReturnCode::CorruptedInput )
         .ignore();
   }
  
   auto ilisteners = m_listenerMap.find( listenerType );
   if ( m_listenerMap.end() == ilisteners ) return;
  
   // setting this pointer will avoid that a call to removeListener() during
   // the loop triggers a segfault
   m_currentIncidentType = &incident.type();
   std::string curIncTyp;
   if ( m_currentIncidentType != nullptr ) {
     curIncTyp = *m_currentIncidentType;
   } else {
     curIncTyp = "UNKNOWN";
   }
  
   bool firedSingleShot = false;
  
   auto& listeners = *ilisteners->second;
  
   for ( auto& listener : listeners ) {
  
     VERMSG << "Calling '" << getListenerName( listener.iListener ) << "' for incident [" << incident.type() << "]"
            << endmsg;
  
     // handle exceptions if they occur
     try {
       listener.iListener->handle( incident );
     } catch ( const GaudiException& exc ) {
       error() << "Exception with tag=" << exc.tag()
               << " is caught"
                  " handling incident "
               << curIncTyp << " in listener " << getListenerName( listener.iListener ) << endmsg;
       error() << exc << endmsg;
       if ( listener.rethrow ) { throw exc; }
     } catch ( const std::exception& exc ) {
       error() << "Standard std::exception is caught"
                  " handling incident "
               << curIncTyp << " in listener " << getListenerName( listener.iListener ) << endmsg;
       error() << exc.what() << endmsg;
       if ( listener.rethrow ) { throw exc; }
     } catch ( ... ) {
       error() << "UNKNOWN Exception is caught"
                  " handling incident "
               << curIncTyp << " in listener " << getListenerName( listener.iListener ) << endmsg;
       if ( listener.rethrow ) { throw; }
     }
     // check wheter one of the listeners is singleShot
     firedSingleShot |= listener.singleShot;
   }
   if ( firedSingleShot ) {
     // remove all the singleshot listeners that got their shot...
     listeners.erase( std::remove_if( std::begin( listeners ), std::end( listeners ), isSingleShot ),
                      std::end( listeners ) );
     if ( listeners.empty() ) m_listenerMap.erase( ilisteners );
   }
  
   m_currentIncidentType = nullptr;
 }

◆ removeListener()

void IncidentSvc::removeListener	(	IIncidentListener *	l,
		const std::string &	type = `""`
	)

override

Definition at line 99 of file IncidentSvc.cpp.

                                                                                 {
   auto lock = std::scoped_lock{ m_listenerMapMutex };
  
   bool scheduleForRemoval = ( m_currentIncidentType && type == *m_currentIncidentType );
   if ( type.empty() ) {
     auto i = std::begin( m_listenerMap );
     while ( i != std::end( m_listenerMap ) ) { i = removeListenerFromList( i, lis, scheduleForRemoval ); }
   } else {
     auto i = m_listenerMap.find( type );
     if ( i != m_listenerMap.end() ) removeListenerFromList( i, lis, scheduleForRemoval );
   }
 }

◆ removeListenerFromList()

IncidentSvc::ListenerMap::iterator IncidentSvc::removeListenerFromList	(	ListenerMap::iterator	i,
		IIncidentListener *	item,
		bool	scheduleRemoval
	)

private

Definition at line 82 of file IncidentSvc.cpp.

                                                                                                           {
   auto match = [&]( ListenerList::const_reference j ) { return !item || item == j.iListener; };
  
   auto& c = *( i->second );
   if ( !scheduleRemoval ) {
     ON_DEBUG std::for_each( std::begin( c ), std::end( c ), [&]( ListenerList::const_reference j ) {
       if ( match( j ) )
         debug() << "Removing [" << i->first << "] listener '" << getListenerName( j.iListener ) << "'" << endmsg;
     } );
     c.erase( std::remove_if( std::begin( c ), std::end( c ), match ), std::end( c ) );
   } else {
     std::for_each( std::begin( c ), std::end( c ), [&]( Listener& i ) {
       if ( match( i ) ) i.singleShot = true; // will trigger removal as soon as it is safe
     } );
   }
   return c.empty() ? m_listenerMap.erase( i ) : std::next( i );
 }

Member Data Documentation

◆ m_currentIncidentType

const std::string* IncidentSvc::m_currentIncidentType = nullptr

private

Incident being fired.

It is used to know if we can safely remove a listener or we have to schedule its removal for later.

Definition at line 70 of file IncidentSvc.h.

◆ m_firedIncidents

tbb::concurrent_unordered_map<EventContext::ContextID_t, IncQueue_t> IncidentSvc::m_firedIncidents

private

Definition at line 81 of file IncidentSvc.h.

◆ m_listenerMap

ListenerMap IncidentSvc::m_listenerMap

private

List of auditor names.

Definition at line 66 of file IncidentSvc.h.

◆ m_listenerMapMutex

std::recursive_mutex IncidentSvc::m_listenerMapMutex

mutableprivate

Mutex to synchronize access to m_listenerMap.

Definition at line 73 of file IncidentSvc.h.

◆ m_slotEvent

tbb::concurrent_unordered_map<EventContext::ContextID_t, EventContext::ContextEvt_t> IncidentSvc::m_slotEvent

private

Event ID for each slot.

Definition at line 84 of file IncidentSvc.h.

◆ m_timer

ChronoEntity IncidentSvc::m_timer

mutableprivate

timer & it's lock

Definition at line 76 of file IncidentSvc.h.

◆ m_timerLock

bool IncidentSvc::m_timerLock = false

mutableprivate

Definition at line 77 of file IncidentSvc.h.

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

GaudiCoreSvc/src/IncidentSvc/IncidentSvc.h
GaudiCoreSvc/src/IncidentSvc/IncidentSvc.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ IncQueue_t

◆ ListenerList

◆ ListenerMap

Constructor & Destructor Documentation

◆ IncidentSvc()

◆ ~IncidentSvc()

Member Function Documentation

◆ addListener()

◆ finalize()

◆ fireIncident() [1/2]

◆ fireIncident() [2/2]

◆ getIncidents()

◆ getListeners()

◆ i_fireIncident()

◆ removeListener()

◆ removeListenerFromList()

Member Data Documentation

◆ m_currentIncidentType

◆ m_firedIncidents

◆ m_listenerMap

◆ m_listenerMapMutex

◆ m_slotEvent

◆ m_timer

◆ m_timerLock