IncidentSvc Class Reference

Default implementation of the IIncidentSvc interface. More...

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

Inheritance diagram for IncidentSvc:

Collaboration diagram for IncidentSvc:

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.
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface.
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames.
Public Member Functions inherited from Service
const std::string &	name () const override
	Retrieve name of the service.
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.
StatusCode	sysStart () override
	Initialize Service.
StatusCode	sysStop () override
	Initialize Service.
StatusCode	sysFinalize () override
	Finalize Service.
StatusCode	sysReinitialize () override
	Re-initialize the Service.
StatusCode	sysRestart () override
	Re-initialize the Service.
	Service (std::string name, ISvcLocator *svcloc)
	Standard Constructor.
SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator.
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.
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.
Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.
StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.
StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value
	PropertyHolder ()=default
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property.
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.
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.
Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property.
StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name
StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.
StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.
StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value
StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation
StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property
const Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name
StatusCode	getProperty (std::string_view n, std::string &v) const override
	convert the property to the string
const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties
bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name.
Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected
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)
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream
Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor.
const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service.
MsgStream &	msgStream () const
	Return an uninitialized MsgStream.
MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts.
MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS)
MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL)
MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR)
MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR)
MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING)
MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO)
MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG)
MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE)
MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO)

Private 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.

Private Attributes
ListenerMap	m_listenerMap
	List of auditor names.
const std::string *	m_currentIncidentType = nullptr
	Incident being fired.
std::recursive_mutex	m_listenerMapMutex
	Mutex to synchronize access to m_listenerMap.
ChronoEntity	m_timer
	timer & it's lock
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.

Additional Inherited Members
Public Types inherited from extends< Service, IIncidentSvc >
using	base_class
	Typedef to this class.
using	extend_interfaces_base
	Typedef to the base of this class.
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
	Typedef used to refer to this class from derived classes, as in.
Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using	base_class
Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids
	take union of the ext_iids of all Interfaces...
Protected Member Functions inherited from Service
std::vector< IAlgTool * > &	tools ()
	~Service () override
int	outputLevel () const
	get the Service's output level
Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	setUpMessaging () const
	Set up local caches.
MSG::Level	resetMessaging ()
	Reinitialize internal states.
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream.
Protected Attributes inherited from Service
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Service state.
Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Service state.
Gaudi::Property< int >	m_outputLevel { this, "OutputLevel", MSG::NIL, "output level" }
	flag indicating whether ToolHandle tools have been added to m_tools
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.

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 39 of file IncidentSvc.cpp.

: base_class( name, svc ) {}

~IncidentSvc()

IncidentSvc::~IncidentSvc ( )

override

Definition at line 40 of file IncidentSvc.cpp.

{ 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 50 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 41 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 185 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 196 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 236 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 221 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 112 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 94 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 77 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