MPIHiveEventLoopMgr Class Reference

The MPI event loop manager. More...

#include <MPIHiveEventLoopMgr.h>

Inheritance diagram for MPIHiveEventLoopMgr:

Collaboration diagram for MPIHiveEventLoopMgr:

Public Types
typedef IEvtSelector::Context	EvtContext
typedef std::list< SmartIF< IAlgorithm > >	ListAlg

Public Member Functions
	MPIHiveEventLoopMgr (const std::string &name, ISvcLocator *svcLoc)
	Standard Constructor.
virtual	~MPIHiveEventLoopMgr ()
	Standard Destructor.
virtual StatusCode	initialize () override
	implementation of IAppMgrUI::initalize
virtual StatusCode	finalize () override
	implementation of IAppMgrUI::finalize
virtual StatusCode	nextEvent (int maxevt) override
	implementation of IAppMgrUI::nextEvent. maxevt==0 returns immediately
StatusCode	getEventRoot (IOpaqueAddress *&refpAddr)
	Create event address using event selector.
virtual StatusCode	executeEvent (EventContext &&ctx) override
	implementation of IEventProcessor::executeEvent(void* par)
virtual StatusCode	executeRun (int maxevt) override
	implementation of IEventProcessor::executeRun(int maxevt)
virtual StatusCode	stopRun () override
	implementation of IEventProcessor::stopRun()
virtual StatusCode	stop () override
	implementation of IService::stop
virtual StatusCode	seek (int evt) override
	Seek to a given event.
virtual int	curEvent () const override
	Return the current event count.
virtual int	size () override
	Return the size of the collection.
virtual void	handle (const Incident &inc) override
	IIncidentListenet interfaces.
virtual const std::string &	name () const override
virtual void	modifyEventContext (EventContext &ctx, const EventID &eID, bool consume_modifier_stream)
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Protected Types
typedef ServiceHandle< IIncidentSvc >	IIncidentSvc_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t
typedef ServiceHandle< IDataManagerSvc >	IDataManagerSvc_t
typedef ServiceHandle< IConversionSvc >	IConversionSvc_t
typedef ServiceHandle< IEvtIdModifierSvc >	IEvtIdModifierSvc_t
typedef EventID::number_type	number_type
typedef IAthenaEvtLoopPreSelectTool	tool_type
typedef ToolHandleArray< tool_type >	tool_store
typedef tool_store::const_iterator	tool_iterator
typedef std::vector< unsigned int >	tool_stats
typedef tool_stats::const_iterator	tool_stats_iterator

Protected Member Functions
StatusCode	drainLocalScheduler ()
	Drain the local scheduler of any (at least one) completed events.
StatusCode	insertEvent (int eventIdx, bool &endOfStream, std::int64_t requestTime_ns)
	Insert an event into the local scheduler.
StatusCode	workerEventLoop ()
	Worker event loop (runs on worker, requests events over MPI).
StatusCode	masterEventLoop (int maxEvt)
	Master event loop (runs on master, provides events over MPI).
void	setupPreSelectTools (Gaudi::Details::PropertyBase &)
	property update handler:sets up the Pre-selection tools
virtual StatusCode	writeHistograms (bool force=false)
	Dump out histograms as needed.
virtual StatusCode	executeAlgorithms ()
	Run the algorithms for the current event.
StatusCode	initializeAlgorithms ()
	Initialize all algorithms and output streams.
StatusCode	clearWBSlot (int evtSlot)
	Clear a slot in the WB.
int	declareEventRootAddress (EventContext &)
	Declare the root address of the event.
virtual EventContext	createEventContext () override
	Create event context.
int	drainScheduler (int &finishedEvents)
	Drain the scheduler from all actions that may be queued.
void	setTimeout (Timeout &instance)
	Set timeout.
void	resetTimeout (Timeout &instance)
	Reset timeout.

Protected Attributes
ServiceHandle< IMPIClusterSvc >	m_clusterSvc
	Reference to the MPIClusterSvc.
int	m_contiguousFailedEvts {0}
int	m_totalFailedEvts {0}
int	m_nLocalCreatedEvts {0}
int	m_nLocalSkippedEvts {0}
int	m_nLocalFinishedEvts {0}
IIncidentSvc_t	m_incidentSvc
	Reference to the incident service.
StoreGateSvc_t	m_eventStore
	Reference to StoreGateSvc;.
IEvtSelector *	m_evtSelector
	Reference to the Event Selector.
EvtContext *	m_evtContext
	Gaudi event selector Context (may be used as a cursor by the evt selector).
StringProperty	m_evtsel
IDataManagerSvc_t	m_histoDataMgrSvc
	Reference to the Histogram Data Service.
IConversionSvc_t	m_histoPersSvc
IEvtIdModifierSvc_t	m_evtIdModSvc
StringProperty	m_histPersName
number_type	m_currentRun
	current run number
bool	m_firstRun
IntegerProperty	m_failureMode
UnsignedIntegerProperty	m_eventPrintoutInterval
tool_stats	m_toolInvoke
	tool called counter
tool_stats	m_toolReject
	tool returns StatusCode::FAILURE counter
tool_stats	m_toolAccept
	tool returns StatusCode::SUCCESS counter
tool_store	m_tools
	internal tool store
bool	m_requireInputAttributeList {}
	require input attribute list
bool	m_useSecondaryEventNumber {}
	read event number from secondary input
SmartIF< IHiveWhiteBoard >	m_whiteboard
	Reference to the Whiteboard interface.
SmartIF< IAlgResourcePool >	m_algResourcePool
	Reference to the Algorithm resource pool.
SmartIF< IAlgExecStateSvc >	m_aess
	Reference to the Algorithm Execution State Svc.
SmartIF< IProperty >	m_appMgrProperty
	Property interface of ApplicationMgr.
SmartIF< IScheduler >	m_schedulerSvc
	A shortcut for the scheduler.
SmartIF< IIncidentListener >	m_abortEventListener
	Instance of the incident listener waiting for AbortEvent.
std::string	m_schedulerName
	Name of the scheduler to be used.
std::string	m_whiteboardName
	Name of the Whiteboard to be used.
bool	m_scheduledStop
	Scheduled stop of event processing.
bool	m_terminateLoop { false }
unsigned int	m_nev
	events processed
unsigned int	m_proc
bool	m_useTools
bool	m_doEvtHeartbeat
EventContext	m_lastEventContext

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
UnsignedIntegerProperty	m_firstEventIndex
int	m_evtSelectorCurrentPos = 0
unsigned int	m_nevt
unsigned int	m_timeStamp { 0 }
UnsignedIntegerProperty	m_writeInterval
bool	m_writeHists
bool	m_firstEventAlone
unsigned int	m_flmbi
unsigned int	m_timeStampInt
ServiceHandle< Athena::IConditionsCleanerSvc >	m_conditionsCleaner
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

The MPI event loop manager.

As with AthenaHiveEventLoopMgr but in a multi-node MPI environment. This class is derived from and implemented in terms of AthenaHiveEventLoopMgr.

Definition at line 34 of file MPIHiveEventLoopMgr.h.

Member Typedef Documentation

EvtContext

typedef IEvtSelector::Context AthenaHiveEventLoopMgr::EvtContext

inherited

Definition at line 74 of file AthenaHiveEventLoopMgr.h.

IConversionSvc_t

typedef ServiceHandle<IConversionSvc> AthenaHiveEventLoopMgr::IConversionSvc_t

protectedinherited

Definition at line 96 of file AthenaHiveEventLoopMgr.h.

IDataManagerSvc_t

typedef ServiceHandle<IDataManagerSvc> AthenaHiveEventLoopMgr::IDataManagerSvc_t

protectedinherited

Definition at line 92 of file AthenaHiveEventLoopMgr.h.

IEvtIdModifierSvc_t

typedef ServiceHandle<IEvtIdModifierSvc> AthenaHiveEventLoopMgr::IEvtIdModifierSvc_t

protectedinherited

Definition at line 100 of file AthenaHiveEventLoopMgr.h.

IIncidentSvc_t

typedef ServiceHandle<IIncidentSvc> AthenaHiveEventLoopMgr::IIncidentSvc_t

protectedinherited

Definition at line 77 of file AthenaHiveEventLoopMgr.h.

ListAlg

typedef std::list<SmartIF<IAlgorithm> > AthenaHiveEventLoopMgr::ListAlg

inherited

Definition at line 264 of file AthenaHiveEventLoopMgr.h.

number_type

typedef EventID::number_type AthenaHiveEventLoopMgr::number_type

protectedinherited

Definition at line 107 of file AthenaHiveEventLoopMgr.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthenaHiveEventLoopMgr::StoreGateSvc_t

protectedinherited

Definition at line 81 of file AthenaHiveEventLoopMgr.h.

tool_iterator

typedef tool_store::const_iterator AthenaHiveEventLoopMgr::tool_iterator

protectedinherited

Definition at line 121 of file AthenaHiveEventLoopMgr.h.

tool_stats

typedef std::vector<unsigned int> AthenaHiveEventLoopMgr::tool_stats

protectedinherited

Definition at line 122 of file AthenaHiveEventLoopMgr.h.

tool_stats_iterator

typedef tool_stats::const_iterator AthenaHiveEventLoopMgr::tool_stats_iterator

protectedinherited

Definition at line 123 of file AthenaHiveEventLoopMgr.h.

tool_store

typedef ToolHandleArray< tool_type > AthenaHiveEventLoopMgr::tool_store

protectedinherited

Definition at line 120 of file AthenaHiveEventLoopMgr.h.

tool_type

typedef IAthenaEvtLoopPreSelectTool AthenaHiveEventLoopMgr::tool_type

protectedinherited

Definition at line 119 of file AthenaHiveEventLoopMgr.h.

Constructor & Destructor Documentation

MPIHiveEventLoopMgr()

MPIHiveEventLoopMgr::MPIHiveEventLoopMgr	(	const std::string &	name,
		ISvcLocator *	svcLoc )

Standard Constructor.

Definition at line 22 of file MPIHiveEventLoopMgr.cxx.

    : AthenaHiveEventLoopMgr(name, svcLoc) {}

~MPIHiveEventLoopMgr()

MPIHiveEventLoopMgr::~MPIHiveEventLoopMgr ( )

virtualdefault

Standard Destructor.

Member Function Documentation

clearWBSlot()

StatusCode AthenaHiveEventLoopMgr::clearWBSlot ( int evtSlot )

protectedinherited

Clear a slot in the WB.

Definition at line 1294 of file AthenaHiveEventLoopMgr.cxx.

                                                           {
  return m_whiteboard->freeStore(evtSlot);  
}

createEventContext()

EventContext AthenaHiveEventLoopMgr::createEventContext ( )

overrideprotectedvirtualinherited

Create event context.

Definition at line 1157 of file AthenaHiveEventLoopMgr.cxx.

                                                        {
 
  EventContext ctx{ m_nevt, m_whiteboard->allocateStore( m_nevt ) };
 
  StatusCode sc = m_whiteboard->selectStore( ctx.slot() );
  if (sc.isFailure()) {
    ATH_MSG_FATAL ( "Slot {} could not be selected for the WhiteBoard",
                    ctx.slot());
    return EventContext{};       // invalid EventContext
  } else {
    Atlas::setExtendedEventContext(ctx,
                                   Atlas::ExtendedEventContext( m_eventStore->hiveProxyDict() ) );
 
    ATH_MSG_DEBUG ( "created EventContext, num: {}  in slot: {}",
                    ctx.evt(), ctx.slot());
  }
 
  return ctx;
}

curEvent()

int AthenaHiveEventLoopMgr::curEvent ( ) const

overridevirtualinherited

Return the current event count.

Definition at line 809 of file AthenaHiveEventLoopMgr.cxx.

{
  return m_nevt;
}

declareEventRootAddress()

int AthenaHiveEventLoopMgr::declareEventRootAddress ( EventContext & ctx )

protectedinherited

Declare the root address of the event.

FIXME ???

Definition at line 936 of file AthenaHiveEventLoopMgr.cxx.

                                                                    {
 
  // return codes:
  //   -1 : error
  //    0 : no more events in selection
  //    1 : ok
  
  StatusCode sc(StatusCode::SUCCESS);
 
  //-----------------------------------------------------------------------
  // we need an EventInfo Object to fire the incidents. 
  //-----------------------------------------------------------------------
  std::unique_ptr<const EventInfo> pEvent{};
  if ( m_evtContext ) {
    // Deal with the case when an EventSelector is provided
    //
    // FIXME: flow control if no more events in selector, etc.
    //
 
    IOpaqueAddress* addr{};
 
    sc = m_evtSelector->next(*m_evtContext);
    
    if ( !sc.isSuccess() ) {
      // This is the end of the loop. No more events in the selection
      ATH_MSG_INFO ( "No more events in event selection " );
      return 0;
    }
    
    if (m_evtSelector->createAddress(*m_evtContext, addr).isFailure()) {
      ATH_MSG_ERROR ( "Could not create an IOpaqueAddress" );
      return -1;
    }
    
      
    // Most iterators provide the IOA of an event header (EventInfo, DataHeader)
    if (0 != addr) {
      //create its proxy
      sc = m_eventStore->recordAddress(addr);
      if( !sc.isSuccess() ) {
    ATH_MSG_WARNING ( "Error declaring Event object" );
    return 0;
      }
    } if ((sc=m_eventStore->loadEventProxies()).isFailure()) {
      ATH_MSG_ERROR ( "Error loading Event proxies" );
      return -1;
    }
 
    bool consume_modifier_stream = false;
    // First try to build a legacy EventInfo object from the TAG information
    // Read the attribute list
    const AthenaAttributeList* pAttrList = m_eventStore->tryConstRetrieve<AthenaAttributeList>("Input");
    if ( pAttrList != nullptr && pAttrList->size() > 6 ) { // Try making EventID-only EventInfo object from in-file TAG
      try {
        unsigned int runNumber = (*pAttrList)["RunNumber"].data<unsigned int>();
        unsigned long long eventNumber = (*pAttrList)["EventNumber"].data<unsigned long long>();
        unsigned int eventTime = (*pAttrList)["EventTime"].data<unsigned int>();
        unsigned int eventTimeNS = (*pAttrList)["EventTimeNanoSec"].data<unsigned int>();
        unsigned int lumiBlock = (*pAttrList)["LumiBlockN"].data<unsigned int>();
        unsigned int bunchId = (*pAttrList)["BunchId"].data<unsigned int>();
 
        ATH_MSG_DEBUG ( "use TAG with runNumber={}", runNumber );
        consume_modifier_stream = true;
        // an option to override primary eventNumber with the secondary one in case of DoubleEventSelector
        if ( m_useSecondaryEventNumber ) {
            unsigned long long eventNumberSecondary{};
            if ( !(pAttrList->exists("hasSecondaryInput") && (*pAttrList)["hasSecondaryInput"].data<bool>()) ) {
                ATH_MSG_FATAL ( "Secondary EventNumber requested, but secondary input does not exist!" );
                return -1;
            }
            if ( pAttrList->exists("EventNumber_secondary") ) {
                eventNumberSecondary = (*pAttrList)["EventNumber_secondary"].data<unsigned long long>();
            }
            else {
                // try legacy EventInfo if secondary input did not have attribute list
                // primary input should not have this EventInfo type
                const EventInfo* pEventSecondary = m_eventStore->tryConstRetrieve<EventInfo>();
                if (pEventSecondary) {
                    eventNumberSecondary = pEventSecondary->event_ID()->event_number();
                }
                else {
                    ATH_MSG_FATAL ( "Secondary EventNumber requested, but it does not exist!" );
                    return -1;
                }
            }
            if (eventNumberSecondary != 0) {
                m_doEvtHeartbeat = (m_eventPrintoutInterval.value() > 0 && 
                  0 == (m_nev % m_eventPrintoutInterval.value()));
                if (m_doEvtHeartbeat) {
                    ATH_MSG_INFO ( "  ===>>>  using secondary event #{} instead of #{}  <<<===",
                                   eventNumberSecondary, eventNumber);
                }
                eventNumber = eventNumberSecondary;
            }
        }
 
        pEvent = std::make_unique<EventInfo>(
            std::make_unique<EventID>(runNumber, eventNumber, eventTime,
                                      eventTimeNS, lumiBlock, bunchId),
            nullptr);
      } catch (...) {
      }
    } else if (m_requireInputAttributeList) {
      ATH_MSG_FATAL ( "Valid input attribute list required but not present!" );
      return -1;
    }
    // In the case that there is no TAG information
    const EventInfo* pEventObserver{pEvent.get()};
    if (!pEventObserver) {
      // Secondly try to retrieve a legacy EventInfo object from the input file
      // Again, m_nevt is incremented after executeEvent in the Hive manager so we don't need a -1
      EventInfoCnvParams::eventIndex = ctx.evt();
      pEventObserver = m_eventStore->tryConstRetrieve<EventInfo>();
      if (pEventObserver) {
        consume_modifier_stream = false; // stream will already have been consumed during EventInfo TP conversion
        ATH_MSG_DEBUG ( "use EventInfo" );
      } else {
        // Finally try to retrieve an xAOD::EventInfo object from the
        // input file and build a legacy EventInfo object from that.
        const xAOD::EventInfo* pXEvent{nullptr};
        sc = m_eventStore->retrieve(pXEvent);
        if( !sc.isSuccess() ) {
          ATH_MSG_ERROR ( "Unable to retrieve Event root object" );
          return -1;
        }
        consume_modifier_stream = true;
        ATH_MSG_DEBUG ( "use xAOD::EventInfo with runNumber={}", pXEvent->runNumber() );
        // Build the old-style Event Info object for those clients that still need it
        pEvent = std::make_unique<EventInfo>(
            std::make_unique<EventID>(eventIDFromxAOD(pXEvent)),
            std::make_unique<EventType>(eventTypeFromxAOD(pXEvent)));
        pEventObserver = pEvent.get();
        sc = m_eventStore->record(std::move(pEvent), "");
        if( !sc.isSuccess() )  {
          ATH_MSG_ERROR ( "Error declaring event data object" );
          return -1;
        }
      }
    }
 
    modifyEventContext(ctx, *(pEventObserver->event_ID()),
                       consume_modifier_stream);
 
  }
  else  {
    // No EventSelector is provided, so with no iterator it's up to us
    // to create an EventInfo
    // first event # == 1
    unsigned int runNmb{1}, evtNmb{m_nevt + 1};
 
    // increment the run/lumiBlock number if desired
    if (m_flmbi != 0) {
      runNmb = m_nevt / m_flmbi + 1;
      evtNmb = m_nevt % m_flmbi + 1;
    }
    auto eid = std::make_unique<EventID> (runNmb,evtNmb, m_timeStamp);
    // Change lumiBlock# to match runNumber
    eid->set_lumi_block( runNmb );
 
    m_timeStamp += m_timeStampInt;
 
    pEvent = std::make_unique<EventInfo>(std::move(eid),
                                         std::make_unique<EventType>());
 
    bool consume_modifier_stream = true;
    // EventInfo TP Conversion not called in this case, so we would
    // want to consume the next IoV from the list in the
    // EvtIdModifierSvc.
    modifyEventContext(ctx,*(pEvent->event_ID()), consume_modifier_stream);
 
    ATH_MSG_DEBUG ( "selecting store: {}", ctx.slot() );
 
    m_whiteboard->selectStore( ctx.slot() ).ignore();
 
    // EventInfo not working with format
    ATH_MSG_DEBUG ( "recording EventInfo " << *pEvent->event_ID() << " in "
            << m_eventStore->name() );
 
    sc = m_eventStore->record(std::move(pEvent), "McEventInfo");
    if( !sc.isSuccess() )  {
      ATH_MSG_ERROR ( "Error declaring event data object" );
      return -1;
    } 
  }
  
  return 1;
}

drainLocalScheduler()

StatusCode MPIHiveEventLoopMgr::drainLocalScheduler ( )

protected

Drain the local scheduler of any (at least one) completed events.

drainLocalScheduler Drain the local scheduler on this MPI rank

Definition at line 382 of file MPIHiveEventLoopMgr.cxx.

                                                    {
 
  StatusCode sc(StatusCode::SUCCESS);
 
  // maybe we can do better
  std::vector<std::unique_ptr<EventContext>> finishedEvtContexts;
 
  EventContext* finishedEvtContext(nullptr);
 
  // Here we wait not to loose cpu resources
  ATH_MSG_DEBUG("drainLocalScheduler: [{}] Waiting for a context",
                m_nLocalFinishedEvts);
  sc = m_schedulerSvc->popFinishedEvent(finishedEvtContext);
 
  // We got past it: cache the pointer
  if (sc.isSuccess()) {
    ATH_MSG_DEBUG("drainLocalScheduler: scheduler not empty: Context "
                  << finishedEvtContext);
    finishedEvtContexts.emplace_back(finishedEvtContext);
  } else {
    // no more events left in scheduler to be drained
    ATH_MSG_DEBUG("drainLocalScheduler: scheduler empty");
    return StatusCode::SUCCESS;
  }
 
  // Let's see if we can pop other event contexts
  while (m_schedulerSvc->tryPopFinishedEvent(finishedEvtContext).isSuccess()) {
    finishedEvtContexts.emplace_back(finishedEvtContext);
  }
 
  // Now we flush them
  StatusCode fail(StatusCode::SUCCESS);
  for (auto& thisFinishedEvtContext : finishedEvtContexts) {
    if (!thisFinishedEvtContext) {
      ATH_MSG_FATAL("Detected nullptr ctxt while clearing WB!");
      fail = StatusCode::FAILURE;
      continue;
    }
 
    // Update event log
    m_clusterSvc->log_completeEvent(
        thisFinishedEvtContext->evt(),
        thisFinishedEvtContext->eventID().run_number(),
        thisFinishedEvtContext->eventID().event_number(),
        m_aess->eventStatus(*thisFinishedEvtContext));
 
    if (m_aess->eventStatus(*thisFinishedEvtContext) != EventStatus::Success) {
      ATH_MSG_ERROR("Failed event detected on "
                    << thisFinishedEvtContext << " w/ fail mode: "
                    << m_aess->eventStatus(*thisFinishedEvtContext));
      ++m_contiguousFailedEvts;
      ++m_totalFailedEvts;
      if (m_contiguousFailedEvts >= 3 || m_totalFailedEvts >= 10) {
        // If we have 3 contiguous failed events or 10 total, end the job
        fail = StatusCode::FAILURE;
        continue;
      }
    } else {
      // Event succeeded, reset contiguous failed events
      m_contiguousFailedEvts = 0;
    }
 
    EventID::number_type n_run(0);
    EventID::event_number_t n_evt(0);
 
    if (m_whiteboard->selectStore(thisFinishedEvtContext->slot()).isSuccess()) {
      n_run = thisFinishedEvtContext->eventID().run_number();
      n_evt = thisFinishedEvtContext->eventID().event_number();
    } else {
      ATH_MSG_ERROR("DrainSched: unable to select store {}",
                    thisFinishedEvtContext->slot());
      thisFinishedEvtContext.reset();
      fail = StatusCode::FAILURE;
      continue;
    }
 
    // Some code still needs global context in addition to that passed in the
    // incident
    Gaudi::Hive::setCurrentContext(*thisFinishedEvtContext);
    m_incidentSvc->fireIncident(
        Incident(name(), IncidentType::EndProcessing, *thisFinishedEvtContext));
 
    ATH_MSG_DEBUG("Clearing slot {} (event {}) of the whiteboard",
                  thisFinishedEvtContext->slot(),
                  thisFinishedEvtContext->evt());
 
    StatusCode sc = clearWBSlot(thisFinishedEvtContext->slot());
    if (!sc.isSuccess()) {
      ATH_MSG_ERROR("Whiteboard slot {} could not be properly cleared",
                    thisFinishedEvtContext->slot());
      if (fail != StatusCode::FAILURE) {
        fail = sc;
      }
      thisFinishedEvtContext.reset();
      continue;
    }
 
    ++m_nLocalFinishedEvts;
 
    writeHistograms().ignore();
    ++m_proc;
 
    if (m_doEvtHeartbeat) {
      if (!m_useTools) {
        ATH_MSG_INFO("  ===>>>  done processing event #{}, run #{} on slot {},  {} events processed so far <<<===",
                     n_evt, n_run, thisFinishedEvtContext->slot(), m_proc);
      } else {
        ATH_MSG_INFO("  ===>>>  done processing event #{}, run #{} on slot {},  {} events read and {} events processed so far <<<===",
                     n_evt, n_run, thisFinishedEvtContext->slot(), m_nev, m_proc);
                     
      }
      std::ofstream outfile("eventLoopHeartBeat.txt");
      if (!outfile) {
        ATH_MSG_ERROR(" unable to open: eventLoopHeartBeat.txt");
        fail = StatusCode::FAILURE;
        thisFinishedEvtContext.reset();
        continue;
      }
      std::println (outfile, "  done processing event #{}, run #{} {} events read so far <<<===",
                    n_evt, n_run, m_nev);
      outfile.close();
    }
 
    ATH_MSG_DEBUG("drainLocalScheduler thisFinishedEvtContext: "
                  << thisFinishedEvtContext);
 
    thisFinishedEvtContext.reset();
  }
 
  return fail;
}

drainScheduler()

int AthenaHiveEventLoopMgr::drainScheduler ( int & finishedEvents )

protectedinherited

Drain the scheduler from all actions that may be queued.

Definition at line 1180 of file AthenaHiveEventLoopMgr.cxx.

                                                       {
 
  StatusCode sc(StatusCode::SUCCESS);
    
  // maybe we can do better
  std::vector<std::unique_ptr<EventContext>> finishedEvtContexts;
 
  EventContext* finishedEvtContext(nullptr);
 
  // Here we wait not to loose cpu resources
  ATH_MSG_DEBUG ( "drainScheduler: [{}] Waiting for a context", finishedEvts);
  sc = m_schedulerSvc->popFinishedEvent(finishedEvtContext);
 
  // We got past it: cache the pointer
  if (sc.isSuccess()){
    // EventContext not working with std::format
    ATH_MSG_DEBUG ( "drainScheduler: scheduler not empty: Context " 
            << finishedEvtContext );
    finishedEvtContexts.emplace_back(finishedEvtContext);
  } else{
    // no more events left in scheduler to be drained
    ATH_MSG_DEBUG ( "drainScheduler: scheduler empty" );
    return 0;
  }
 
  // Let's see if we can pop other event contexts
  while (m_schedulerSvc->tryPopFinishedEvent(finishedEvtContext).isSuccess()){
    finishedEvtContexts.emplace_back(finishedEvtContext);
  }
 
  // Now we flush them
  bool fail(false);
  for (auto& thisFinishedEvtContext : finishedEvtContexts){
    if (!thisFinishedEvtContext) {
      ATH_MSG_FATAL ( "Detected nullptr ctxt while clearing WB!");
      fail = true;
      continue;
    }
 
    if (m_aess->eventStatus(*thisFinishedEvtContext) != EventStatus::Success) {
      // EventContext not working with std::format
      ATH_MSG_FATAL ( "Failed event detected on " << thisFinishedEvtContext 
              << " w/ fail mode: "
              << m_aess->eventStatus(*thisFinishedEvtContext) );
      fail = true;
      continue;
    }
    
    EventID::number_type n_run(0);
    EventID::event_number_t n_evt(0);
 
    if (m_whiteboard->selectStore(thisFinishedEvtContext->slot()).isSuccess()) {
      n_run = thisFinishedEvtContext->eventID().run_number();
      n_evt = thisFinishedEvtContext->eventID().event_number();
    } else {
      ATH_MSG_ERROR ( "DrainSched: unable to select store {}",
                      thisFinishedEvtContext->slot() );
      fail = true;
      continue;
    }
 
    // m_incidentSvc->fireIncident(Incident(name(), IncidentType::EndEvent,
    //                   *thisFinishedEvtContext ));
    
    // Some code still needs global context in addition to that passed in the incident
    Gaudi::Hive::setCurrentContext( *thisFinishedEvtContext );
    m_incidentSvc->fireIncident(Incident(name(), IncidentType::EndProcessing, *thisFinishedEvtContext ));
 
    ATH_MSG_DEBUG( "Clearing slot {} (event {}) of the whiteboard",
                   thisFinishedEvtContext->slot(),
                   thisFinishedEvtContext->evt() );
    
    StatusCode sc = clearWBSlot(thisFinishedEvtContext->slot());
    if (!sc.isSuccess()) {
      ATH_MSG_ERROR ( "Whiteboard slot {} could not be properly cleared",
                      thisFinishedEvtContext->slot() );
      fail = true;
      continue;
    }
    
    finishedEvts++;
 
    writeHistograms().ignore();
    ++m_proc;
 
    if (m_doEvtHeartbeat) {
      if(!m_useTools) 
        ATH_MSG_INFO ( "  ===>>>  done processing event #{}, run #{} on slot {},  {} events processed so far  <<<===",
                       n_evt, n_run, thisFinishedEvtContext->slot(), m_proc);
      else 
    ATH_MSG_INFO ( "  ===>>>  done processing event #{}, run #{} on slot {},  {} events read and {} events processed so far <<<===",
                       n_evt, n_run, thisFinishedEvtContext->slot(), m_nev, m_proc);
      std::ofstream outfile( "eventLoopHeartBeat.txt");
      if ( !outfile ) {
    ATH_MSG_ERROR ( " unable to open: eventLoopHeartBeat.txt" );
    fail = true;
    continue;
      } else {
        std::println (outfile, "  done processing event #{}, run #{} {} events read so far  <<<===",
                    n_evt, n_run, m_nev);
    outfile.close();
      }  
    }
 
    // EventContext not working with format.
    ATH_MSG_DEBUG ( "drainScheduler thisFinishedEvtContext: " << thisFinishedEvtContext );
  }
 
  return (  fail ? -1 : 1 );
 
}

executeAlgorithms()

StatusCode AthenaHiveEventLoopMgr::executeAlgorithms ( )

protectedvirtualinherited

Run the algorithms for the current event.

Definition at line 478 of file AthenaHiveEventLoopMgr.cxx.

                                                     {
 
  return StatusCode::SUCCESS;
}

executeEvent()

StatusCode AthenaHiveEventLoopMgr::executeEvent ( EventContext && ctx )

overridevirtualinherited

implementation of IEventProcessor::executeEvent(void* par)

Fire begin-Run incident if new run:

Definition at line 487 of file AthenaHiveEventLoopMgr.cxx.

{
 
  // An incident may schedule a stop, in which case is better to exit before the actual execution.
  if ( m_scheduledStop ) {
    ATH_MSG_ALWAYS ( "A stopRun was requested by an incidentListener. "
                     "Do not process this event." );
    m_terminateLoop = true;
    return (StatusCode::SUCCESS);
  }
 
  m_aess->reset( ctx );
 
  // Make sure context with slot is set before calling es->next().
  Gaudi::Hive::setCurrentContext ( ctx );
 
  int declEvtRootSc = declareEventRootAddress( ctx );
  if (declEvtRootSc == 0 ) { // We ran out of events!
    m_terminateLoop = true;  // we have finished!
    return StatusCode::SUCCESS;
  } else if ( declEvtRootSc == -1) {
    // No std::format for EventContext
    ATH_MSG_ERROR ( "declareEventRootAddress for context " << ctx << " failed" );
    return StatusCode::FAILURE;
  }
 
  EventID::event_number_t evtNumber = ctx.eventID().event_number();
  unsigned int conditionsRun = ctx.eventID().run_number();
  if (!m_evtIdModSvc.isSet()) {
    const AthenaAttributeList* attr = nullptr;
    if (m_eventStore->contains<AthenaAttributeList> ("Input") &&
        m_eventStore->retrieve(attr, "Input").isSuccess()) {
      if (attr->exists ("ConditionsRun")) {
        conditionsRun = (*attr)["ConditionsRun"].data<unsigned int>();
      }
    }
  }
  Atlas::getExtendedEventContext(ctx).setConditionsRun (conditionsRun);
  Gaudi::Hive::setCurrentContext ( ctx );
 
  // Record EventContext in current whiteboard
  if (m_eventStore->record(std::make_unique<EventContext> (ctx),
                           "EventContext").isFailure())
  {
    ATH_MSG_ERROR ( "Error recording event context object" );
    return (StatusCode::FAILURE);
  }

  if (m_firstRun || (m_currentRun != ctx.eventID().run_number()) ) {
    // Fire EndRun incident unless this is the first run
    if (!m_firstRun) {
      // FIXME!!!
      m_incidentSvc->fireIncident(Incident(name(), IncidentType::EndRun));
    }
    m_firstRun=false;
    m_currentRun = ctx.eventID().run_number();
 
    ATH_MSG_INFO ( "  ===>>>  start of run {}    <<<===", m_currentRun);
 
    // FIXME!!! Fire BeginRun "Incident"
    m_incidentSvc->fireIncident(Incident(name(),IncidentType::BeginRun,ctx));
 
  }
 
  bool toolsPassed=true;
  // CGL: FIXME
  // bool eventFailed = false;
 
  // Call any attached tools to reject events early
  unsigned int toolCtr=0;
  if(m_useTools) {
    tool_store::iterator theTool = m_tools.begin();
    tool_store::iterator lastTool  = m_tools.end();
    while(toolsPassed && theTool!=lastTool ) 
      {
        toolsPassed = (*theTool)->passEvent(ctx.eventID());
    m_toolInvoke[toolCtr]++;
        {toolsPassed ? m_toolAccept[toolCtr]++ : m_toolReject[toolCtr]++;}
        ++toolCtr;
        ++theTool;
      }
  }
 
  m_doEvtHeartbeat = (m_eventPrintoutInterval.value() > 0 && 
         0 == (m_nev % m_eventPrintoutInterval.value()));
  if (m_doEvtHeartbeat)  {
    if(!m_useTools) {
      ATH_MSG_INFO ( "  ===>>>  start processing event #{}, run #{} on slot {},  {} events processed so far  <<<===",
                     evtNumber, m_currentRun, ctx.slot(), m_proc);
    }
    else {
      ATH_MSG_INFO ( "  ===>>>  start processing event #{}, run #{} on slot {},  {} events read and {} events processed so far  <<<===",
                     evtNumber, m_currentRun, ctx.slot(), m_nev, m_proc);
    }
  }
 
  // Reset the timeout singleton
  resetTimeout(Athena::Timeout::instance(ctx));
  if(toolsPassed) {
 
    CHECK( m_conditionsCleaner->event (ctx, true) );
 
    // Remember the last event context for after event processing finishes.
    m_lastEventContext = ctx;
    
    // Now add event to the scheduler 
    ATH_MSG_DEBUG ( "Adding event {}, slot {} to the scheduler",
                    ctx.evt(), ctx.slot());
    
    m_incidentSvc->fireIncident(Incident(name(), IncidentType::BeginProcessing, 
                     ctx));
    StatusCode addEventStatus = m_schedulerSvc->pushNewEvent( new EventContext{ std::move(ctx) } );
    
    // If this fails, we need to wait for something to complete
    if (!addEventStatus.isSuccess()){
      ATH_MSG_FATAL ( "An event processing slot should be now free in the scheduler, but it appears not to be the case." );
    }
    
  }  // end of toolsPassed test
 
  ++m_nev;
 
  ++m_nevt;
 
  // invalidate thread local context once outside of event execute loop
  Gaudi::Hive::setCurrentContext( EventContext() );
 
  return StatusCode::SUCCESS;
 
}

executeRun()

StatusCode AthenaHiveEventLoopMgr::executeRun ( int maxevt )

overridevirtualinherited

implementation of IEventProcessor::executeRun(int maxevt)

Definition at line 622 of file AthenaHiveEventLoopMgr.cxx.

{
 
  StatusCode  sc;
  bool eventfailed = false;
  
  // Call now the nextEvent(...)
  sc = nextEvent(maxevt);
  if (!sc.isSuccess())
    eventfailed = true;
 
  if (eventfailed)
    return StatusCode::FAILURE;
 
  m_incidentSvc->fireIncident(Incident(name(),"EndEvtLoop"));
  return StatusCode::SUCCESS;
}

finalize()

StatusCode MPIHiveEventLoopMgr::finalize ( )

overridevirtual

implementation of IAppMgrUI::finalize

Finalize Finalizes AthenaHiveEventLoopMgr.

Reimplemented from AthenaHiveEventLoopMgr.

Definition at line 39 of file MPIHiveEventLoopMgr.cxx.

                                         {
  return AthenaHiveEventLoopMgr::finalize();
}

getEventRoot()

StatusCode AthenaHiveEventLoopMgr::getEventRoot ( IOpaqueAddress *& refpAddr )

inherited

Create event address using event selector.

Definition at line 914 of file AthenaHiveEventLoopMgr.cxx.

                                                                          {
  refpAddr = 0;
  StatusCode sc = m_evtSelector->next(*m_evtContext);
  if ( !sc.isSuccess() )  {
    return sc;
  }
  // Create root address and assign address to data service
  sc = m_evtSelector->createAddress(*m_evtContext,refpAddr);
  if( !sc.isSuccess() )  {
    sc = m_evtSelector->next(*m_evtContext);
    if ( sc.isSuccess() )  {
      sc = m_evtSelector->createAddress(*m_evtContext,refpAddr);
      if ( !sc.isSuccess() )  {
        ATH_MSG_WARNING ( "Error creating IOpaqueAddress." );
      }
    }
  }
  return sc;
}

handle()

void AthenaHiveEventLoopMgr::handle ( const Incident & inc )

overridevirtualinherited

IIncidentListenet interfaces.

Definition at line 839 of file AthenaHiveEventLoopMgr.cxx.

{
 
  if(inc.type() == "EndAlgorithms") {
    // Clear the store at the end of the event.
    // Do it here so that it executes in an algorithm context and thus
    // multiple stores can be cleared at the same time.
    StatusCode sc = m_whiteboard->clearStore(inc.context().slot());
    if( !sc.isSuccess() )  {
      ATH_MSG_WARNING ( "Clear of Event data store failed" );
    }
    return;
  }
 
  if(inc.type()!="BeforeFork")
    return;
 
  if(!m_evtContext || !m_firstRun) {
    ATH_MSG_WARNING ( "Skipping BeforeFork handler. Either no event selector is provided or begin run has already passed" );
  }
 
  // Initialize Algorithms and Output Streams
  StatusCode sc = initializeAlgorithms();
  if(sc.isFailure()) {
    ATH_MSG_ERROR ( "Failed to initialize Algorithms" );
    return; 
  }
 
  // Construct EventInfo
  sc = m_evtSelector->next(*m_evtContext);
  if(!sc.isSuccess()) {
    ATH_MSG_INFO ( "No more events in event selection " );
    return;
  }
  IOpaqueAddress* addr{nullptr};
  sc = m_evtSelector->createAddress(*m_evtContext, addr);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "Could not create an IOpaqueAddress" );
    return;
  }
  if (0 != addr) {
    //create its proxy
    sc = m_eventStore->recordAddress(addr);
    if(!sc.isSuccess()) {
      ATH_MSG_ERROR ( "Error declaring Event object" );
      return;
    }
  }
 
  if(m_eventStore->loadEventProxies().isFailure()) {
    ATH_MSG_WARNING ( "Error loading Event proxies" );
    return;
  }
 
  // Retrieve the legacy EventInfo object
  const EventInfo* pEvent{nullptr};
  sc = m_eventStore->retrieve(pEvent);
  if(!sc.isSuccess()) {
    ATH_MSG_ERROR ( "Unable to retrieve Event root object" );
    return;
  }
 
  m_firstRun=false;
  m_currentRun = pEvent->event_ID()->run_number();
 
  // Clear Store
  sc = m_eventStore->clearStore();
  if(!sc.isSuccess()) {
    ATH_MSG_ERROR ( "Clear of Event data store failed" );
  }
}

initialize()

StatusCode MPIHiveEventLoopMgr::initialize ( )

overridevirtual

implementation of IAppMgrUI::initalize

Initialize Initializes AthenaHiveEventLoop and MPIClusterSvc.

Reimplemented from AthenaHiveEventLoopMgr.

Definition at line 31 of file MPIHiveEventLoopMgr.cxx.

                                           {
  // Initialize cluster svc
  ATH_CHECK(m_clusterSvc.retrieve());
  return AthenaHiveEventLoopMgr::initialize();
}

initializeAlgorithms()

StatusCode AthenaHiveEventLoopMgr::initializeAlgorithms ( )

protectedinherited

Initialize all algorithms and output streams.

Definition at line 470 of file AthenaHiveEventLoopMgr.cxx.

                                                        {
 
  return StatusCode::SUCCESS;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

insertEvent()

StatusCode MPIHiveEventLoopMgr::insertEvent ( int eventIdx, bool & endOfStream, std::int64_t requestTime_ns )

protected

Insert an event into the local scheduler.

Insert event into local scheduler.

Definition at line 335 of file MPIHiveEventLoopMgr.cxx.

                                                                       {
  // fast-forward to event
  // Create the event context now so next writes into the next slot when
  // skipping, not the one that's being used
  endOfStream = false;
  auto ctx = createEventContext();
  Gaudi::Hive::setCurrentContext(ctx);
  ctx.setEvt(
      eventIdx);  // Make the event numbers in the log actually make sense
  if (!ctx.valid()) {
    endOfStream = true;  // BUG: Doesn't actually mean end of stream. Remove
                         // after making sure!
    return StatusCode::FAILURE;
  }
 
  const std::size_t slot = ctx.slot();  // Need this for later
  // Codex (GPT 5.6-sol) identified use of seek should be reverted since that
  // function isn't implemented properly
  if (m_evtSelector != nullptr) {
    const int nToJump = (eventIdx - 1) - m_evtSelectorCurrentPos;
    if (nToJump < 0) {
      ATH_MSG_ERROR("Cannot jump backwards by {} events", nToJump);
      return StatusCode::FAILURE;
    }
    if (nToJump > 0) {
      ATH_CHECK(m_evtSelector->next(*m_evtContext, nToJump));
    }
    m_evtSelectorCurrentPos = eventIdx;
  }
  // execute event
  StatusCode sc = executeEvent(std::move(ctx));
  const auto evtID =
      m_lastEventContext.eventID();  // Set in AthenaHiveEventLoopMgr
  m_clusterSvc->log_addEvent(eventIdx, evtID.run_number(), evtID.event_number(),
                             requestTime_ns, slot);
 
  if (sc.isRecoverable()) {
    ++m_nLocalSkippedEvts;
  } else if (sc.isSuccess()) {
    ++m_nLocalCreatedEvts;
  }
  return sc;
}

masterEventLoop()

StatusCode MPIHiveEventLoopMgr::masterEventLoop ( int maxEvt )

protected

Master event loop (runs on master, provides events over MPI).

Master event loop.

Definition at line 63 of file MPIHiveEventLoopMgr.cxx.

                                                          {
  ATH_MSG_INFO("Running with " << m_clusterSvc->numRanks() << " ranks");
  // Determine number of events to process
  int skipEvts = int(m_firstEventIndex.value());
  if (m_evtSelector != nullptr) {
    int evt = size();
    if (evt == -1) {
      m_clusterSvc->abort();
      return StatusCode::FAILURE;
    }
    if (maxEvt < 0 || (skipEvts + maxEvt) > evt) {
      maxEvt = evt - skipEvts;
    }
    ATH_MSG_INFO("Will be processing " << maxEvt << " events");
  }
 
  // Setup worker status DB (Spare one at start)
  std::vector<bool> workers_done(m_clusterSvc->numRanks(), false);
  workers_done[0] =
      true;  // Set 0 to true because it doesn't correspond to a worker
  int num_workers_done = 1;  // Init to 1 so we can compare to numRanks
  std::vector<ClusterMessage::WorkerStatus> statuses(m_clusterSvc->numRanks());
 
  // Entering event loop
  m_clusterSvc->barrier();
  // Note: no ++evt. This is because this is really a message loop, and we don't
  // want to increment evt if we haven't provided an event
  auto start = Clock::now();
  for (int evt = skipEvts; evt < skipEvts + maxEvt;) {
    ClusterMessage msg = m_clusterSvc->waitReceiveMessage();
    // Messages we can get are RequestEvent, FinalWorkerStatus, or WorkerError
    if (msg.messageType == ClusterMessageType::RequestEvent) {
      ATH_MSG_DEBUG("Starting event " << evt << " on " << msg.source);
      m_clusterSvc->sendMessage(
          msg.source, ClusterMessage(ClusterMessageType::ProvideEvent, evt));
      ++evt;
      continue;
    }
 
    if (msg.messageType == ClusterMessageType::WorkerError) {
      ATH_MSG_ERROR("Received WorkerError message from " << msg.source);
      statuses.at(msg.source) = get<ClusterMessage::WorkerStatus>(msg.payload);
      workers_done.at(msg.source) =
          true;  // If a worker hits an error, it's done
      ++num_workers_done;
      for (int i = 1; i < m_clusterSvc->numRanks(); ++i) {
        if (!workers_done.at(i)) {
          // Tell workers that aren't done to emergency stop
          m_clusterSvc->sendMessage(
              i, ClusterMessage(ClusterMessageType::EmergencyStop));
          workers_done[i] = true;
          ++num_workers_done;
        }
      }
      break;
    }
 
    if (msg.messageType == ClusterMessageType::FinalWorkerStatus) {
      ATH_MSG_INFO("Received FinalWorkerStatus from " << msg.source);
      statuses.at(msg.source) = get<ClusterMessage::WorkerStatus>(msg.payload);
      workers_done.at(msg.source) = true;  // Worker hit end of stream
      ++num_workers_done;
      continue;
    }
 
    // Other message types are an error
    ATH_MSG_ERROR("Received unexpected message {} from {}",
                  msg.messageType, msg.source);
  }
  auto all_provided = Clock::now() - start;
  ATH_MSG_INFO("Provided all events to workers, waiting for them to complete.");
  // Event loop done, tell remaining workers
  while (num_workers_done < m_clusterSvc->numRanks()) {
    ClusterMessage msg = m_clusterSvc->waitReceiveMessage();
    // Messages we can get are RequestEvent, FinalWorkerStatus, or WorkerError
    if (msg.messageType == ClusterMessageType::RequestEvent) {
      m_clusterSvc->sendMessage(msg.source,
                                ClusterMessage(ClusterMessageType::EventsDone));
      continue;
    }
 
    if (msg.messageType == ClusterMessageType::WorkerError) {
      ATH_MSG_ERROR("Received WorkerError message from {}", msg.source);
      statuses.at(msg.source) = get<ClusterMessage::WorkerStatus>(msg.payload);
      workers_done.at(msg.source) =
          true;  // If a worker hits an error, it's done
      ++num_workers_done;
      for (int i = 1; i < m_clusterSvc->numRanks(); ++i) {
        if (!workers_done.at(i)) {
          // Tell workers that aren't done to emergency stop
          m_clusterSvc->sendMessage(
              i, ClusterMessage(ClusterMessageType::EmergencyStop));
          workers_done[i] = true;
          ++num_workers_done;
        }
      }
      break;
    }
 
    if (msg.messageType == ClusterMessageType::FinalWorkerStatus) {
      ATH_MSG_INFO("Received FinalWorkerStatus from {}", msg.source);
      statuses.at(msg.source) = get<ClusterMessage::WorkerStatus>(msg.payload);
      workers_done.at(msg.source) = true;  // Told worker we're done
      ++num_workers_done;
      continue;
    }
 
    // Other message types are an error
    ATH_MSG_ERROR("Received unexpected message {} from {}",
                  msg.messageType, msg.source);
  }
  auto all_done = Clock::now() - start;
  // Collate status
  int n_created = 0;
  int n_skipped = 0;
  int n_finished = 0;
 
  StatusCode sc = StatusCode::SUCCESS;
  int worker_idx = 0;
  for (const auto& worker_status : statuses) {
    if (worker_status.status.isFailure() &&
        worker_status.status != StatusCode(9999)) {
      sc = worker_status.status;
    }
    n_created += worker_status.createdEvents;
    n_skipped += worker_status.skippedEvents;
    n_finished += worker_status.finishedEvents;
 
    if ((worker_idx++) != 0) {
      ATH_MSG_INFO("Worker " << worker_idx << ": SC " << worker_status.status
                             << ", created " << worker_status.createdEvents
                             << ", skipped " << worker_status.skippedEvents
                             << ", finished " << worker_status.finishedEvents);
    }
  }
 
  ATH_MSG_INFO("Overall: SC " << sc << ", created " << n_created << ", skipped "
                              << n_skipped << ", finished " << n_finished);
  ATH_MSG_INFO("MASTER: Took {} to provide all events.",
               std::chrono::hh_mm_ss(all_provided));
  ATH_MSG_INFO("MASTER: Took {} to complete all events.",
               std::chrono::hh_mm_ss(all_done));
  return sc;
}

modifyEventContext()

void AthenaHiveEventLoopMgr::modifyEventContext ( EventContext & ctx, const EventID & eID, bool consume_modifier_stream )

virtualinherited

Definition at line 1127 of file AthenaHiveEventLoopMgr.cxx.

                                                                                                                   {
 
  if(m_evtIdModSvc.isSet()) {
    EventID new_eID(eID);
    // In Hive EventLoopMgr ctx.evt() gets set to m_nevt and *then* m_nevt is
    // incremented later so it's zero-indexed and we don't need to subtract one
    m_evtIdModSvc->modify_evtid(new_eID, ctx.evt(), consume_modifier_stream);
    if (msgLevel(MSG::DEBUG)) {
      unsigned int oldrunnr=eID.run_number();
      unsigned int oldLB=eID.lumi_block();
      unsigned int oldTS=eID.time_stamp();
      unsigned int oldTSno=eID.time_stamp_ns_offset();
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc runnr={} -> {}",
                      oldrunnr, new_eID.run_number());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc LB={} -> {}",
                      oldLB, new_eID.lumi_block());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc TimeStamp={} -> {}",
                      oldTS, new_eID.time_stamp());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc TimeStamp ns Offset={} -> {}",
                      oldTSno, new_eID.time_stamp_ns_offset());
    }
    ctx.setEventID( new_eID );
    Atlas::getExtendedEventContext(ctx).setConditionsRun( ctx.eventID().run_number() );
    return;
  }
 
  ctx.setEventID( eID );
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 92 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 99 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 86 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

name()

virtual const std::string & AthenaHiveEventLoopMgr::name ( ) const

inlineoverridevirtualinherited

Definition at line 228 of file AthenaHiveEventLoopMgr.h.

{ return Service::name(); } //FIXME 

nextEvent()

StatusCode MPIHiveEventLoopMgr::nextEvent ( int maxevt )

overridevirtual

implementation of IAppMgrUI::nextEvent. maxevt==0 returns immediately

nextEvent Dispatches to either masterEventLoop or workerEventLoop

Reimplemented from AthenaHiveEventLoopMgr.

Definition at line 45 of file MPIHiveEventLoopMgr.cxx.

                                                    {
  // make nextEvent(0) a dummy call
  if (0 == maxevt) {
    return StatusCode::SUCCESS;
  }
 
  // Reset the application return code.
  Gaudi::setAppReturnCode(m_appMgrProperty, Gaudi::ReturnCode::Success, true)
      .ignore();
  ATH_MSG_INFO("Starting loop on events");
 
  if (m_clusterSvc->rank() == 0) {
    return masterEventLoop(maxevt);
  }
  return workerEventLoop();
}

resetTimeout()

void Athena::TimeoutMaster::resetTimeout ( Timeout & instance )

inlineprotectedinherited

Reset timeout.

Definition at line 83 of file Timeout.h.

{ instance.reset(); }

seek()

StatusCode AthenaHiveEventLoopMgr::seek ( int evt )

overridevirtualinherited

Seek to a given event.

Definition at line 777 of file AthenaHiveEventLoopMgr.cxx.

{
  IEvtSelectorSeek* is = dynamic_cast<IEvtSelectorSeek*> (m_evtSelector);
  if (is == 0) {
    ATH_MSG_ERROR ( "Seek failed; unsupported by event selector" );
    return StatusCode::FAILURE;
  }
  //cppcheck-suppress nullPointerRedundantCheck
  if (!m_evtContext) {
    if (m_evtSelector->createContext(m_evtContext).isFailure()) {
      ATH_MSG_FATAL ( "Can not create the event selector Context." );
      return StatusCode::FAILURE;
    }
  }
  //m_evtContext cannot be null if createContext succeeded
  //cppcheck-suppress nullPointerRedundantCheck
  StatusCode sc = is->seek (*m_evtContext, evt);
  if (sc.isSuccess()) {
    m_incidentSvc->fireIncident(ContextIncident<std::tuple<int, int>>(
        name(), "SkipEvents", std::tuple<int, int>(m_nevt, evt)));
    m_nevt = evt;
  }
  else {
    ATH_MSG_ERROR ( "Seek failed." );
  }
  return sc;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setTimeout()

void Athena::TimeoutMaster::setTimeout ( Timeout & instance )

inlineprotectedinherited

Set timeout.

Definition at line 80 of file Timeout.h.

{ instance.set(); }

setupPreSelectTools()

void AthenaHiveEventLoopMgr::setupPreSelectTools ( Gaudi::Details::PropertyBase & )

protectedinherited

property update handler:sets up the Pre-selection tools

Definition at line 322 of file AthenaHiveEventLoopMgr.cxx.

                                                                     {
 
  m_toolInvoke.clear();
  m_toolReject.clear();
  m_toolAccept.clear();
 
  m_tools.retrieve().ignore();
  if(m_tools.size() > 0) {
    m_useTools=true;
    m_toolInvoke.resize(m_tools.size());
    m_toolReject.resize(m_tools.size());
    m_toolAccept.resize(m_tools.size());
 
    tool_iterator firstTool = m_tools.begin();
    tool_iterator lastTool  = m_tools.end();
    unsigned int toolCtr = 0;
    for ( ; firstTool != lastTool; ++firstTool )
      {
    // reset statistics
    m_toolInvoke[toolCtr] = 0;
    m_toolReject[toolCtr] = 0;
    m_toolAccept[toolCtr] = 0;
        toolCtr++;
      }
  }
 
  return;
 
}

size()

int AthenaHiveEventLoopMgr::size ( )

overridevirtualinherited

Return the size of the collection.

Definition at line 817 of file AthenaHiveEventLoopMgr.cxx.

{
  IEvtSelectorSeek* cs = dynamic_cast<IEvtSelectorSeek*> (m_evtSelector);
  if (cs == 0) {
    ATH_MSG_ERROR ( "Collection size unsupported by event selector" );
    return -1;
  }
  //cppcheck-suppress nullPointerRedundantCheck
  if (!m_evtContext) {
    if (m_evtSelector->createContext(m_evtContext).isFailure()) {
      ATH_MSG_FATAL ( "Can not create the event selector Context." );
      return -1;
    }
  }
  //m_evtContext cannot be null if createContext succeeded
  //cppcheck-suppress nullPointerRedundantCheck
  return cs->size (*m_evtContext);
}

stop()

StatusCode AthenaHiveEventLoopMgr::stop ( )

overridevirtualinherited

implementation of IService::stop

Definition at line 657 of file AthenaHiveEventLoopMgr.cxx.

{
  // To enable conditions access during stop we set an invalid EventContext
  // (no event/slot number) but with valid EventID (and extended EventContext).
  m_lastEventContext.setValid(false);
  Gaudi::Hive::setCurrentContext( m_lastEventContext );
 
  StatusCode sc = MinimalEventLoopMgr::stop();
 
  // If we exit the event loop early due to an error, some event stores
  // may not have been cleared.  This can lead to segfaults later,
  // as DetectorStore will usually get finalized before HiveSvcMgr.
  // So make sure that all stores have been cleared at this point.
  size_t nslot = m_whiteboard->getNumberOfStores();
  for (size_t islot = 0; islot < nslot; islot++) {
    sc &= clearWBSlot (islot);
  }
 
  Gaudi::Hive::setCurrentContext( EventContext() );
  return sc;
}

stopRun()

StatusCode AthenaHiveEventLoopMgr::stopRun ( )

overridevirtualinherited

implementation of IEventProcessor::stopRun()

Definition at line 642 of file AthenaHiveEventLoopMgr.cxx.

                                           {
  // Set the application return code
  SmartIF<IProperty> appmgr(serviceLocator());
  if(Gaudi::setAppReturnCode(appmgr, Gaudi::ReturnCode::ScheduledStop, true).isFailure()) {
    ATH_MSG_ERROR ( "Could not set return code of the application ({})",
                    Gaudi::ReturnCode::ScheduledStop);
  }
  m_scheduledStop = true;
  return StatusCode::SUCCESS;
}

workerEventLoop()

StatusCode MPIHiveEventLoopMgr::workerEventLoop ( )

protected

Worker event loop (runs on worker, requests events over MPI).

Worker event loop.

Definition at line 209 of file MPIHiveEventLoopMgr.cxx.

                                                {
  bool end_of_stream = false;
  // barrier so all ranks enter message loop together
  m_clusterSvc->barrier();
  auto start = Clock::now();
  m_evtSelectorCurrentPos = int(m_firstEventIndex.value()) - 1;
  while (true) {
    // Drain the scheduler (wait for at least one event to complete, then free
    // up completed slots) in two circumstances
    // 1. Have created exactly one event, so the first event runs to completion
    // before any more are scheduled
    // 2. There are no free slots left
    bool haveFreeSlots =
        m_schedulerSvc->freeSlots() > 0 && m_whiteboard->freeSlots() > 0;
    if (!haveFreeSlots || m_nLocalCreatedEvts == 1) {
      StatusCode sc = drainLocalScheduler();
      if (sc.isFailure()) {
        ClusterMessage::WorkerStatus status{};
        status.status = sc;
        status.createdEvents = m_nLocalCreatedEvts;
        status.skippedEvents = m_nLocalSkippedEvts;
        status.finishedEvents = m_nLocalFinishedEvts;
        m_clusterSvc->sendMessage(
            0, ClusterMessage(ClusterMessageType::WorkerError, status));
        return sc;
      }
    }
 
    auto start_time = Clock::now();
    m_clusterSvc->sendMessage(0,
                              ClusterMessage(ClusterMessageType::RequestEvent));
    ClusterMessage msg = m_clusterSvc->waitReceiveMessage();
    auto request_time = Clock::now() - start_time;
    if (msg.messageType == ClusterMessageType::EmergencyStop) {
      // Emergency stop, return FAILURE after fully draining the scheduler to
      // prevent segfault
      std::size_t numSlots = m_whiteboard->getNumberOfStores();
      while (m_schedulerSvc->freeSlots() < numSlots) {
        // Ignore StatusCode, going to return FAILURE anyway
        (void)(drainLocalScheduler());
      }
      ATH_MSG_ERROR("Received EmergencyStop message!");
      return StatusCode::FAILURE;
    }
 
    if (msg.messageType == ClusterMessageType::EventsDone) {
      auto loop_time = Clock::now() - start;
      ATH_MSG_INFO("Worker {} DONE. Loop took {} to process {} events.",
                   m_clusterSvc->rank(),
                   std::chrono::hh_mm_ss(loop_time),
                   m_nLocalCreatedEvts);
      // Been told we've reached end
      // Provide status to master
      ClusterMessage::WorkerStatus status{};
      // At end of stream, we need to *fully* drain the scheduler
      StatusCode sc = StatusCode::SUCCESS;
      std::size_t numSlots = m_whiteboard->getNumberOfStores();
      while (sc.isSuccess() && m_schedulerSvc->freeSlots() < numSlots) {
        sc = drainLocalScheduler();
      }
      status.status = sc;
      status.createdEvents = m_nLocalCreatedEvts;
      status.skippedEvents = m_nLocalSkippedEvts;
      status.finishedEvents = m_nLocalFinishedEvts;
      m_clusterSvc->sendMessage(
          0, ClusterMessage(ClusterMessageType::FinalWorkerStatus, status));
      return sc;
    }
 
    // Any other message other than ProvideEvent would now be an error
    if (msg.messageType != ClusterMessageType::ProvideEvent ||
        msg.source != 0) {
      ATH_MSG_ERROR("Received unexpected message {} from {}",
                    msg.messageType, msg.source);
      ClusterMessage::WorkerStatus status{};
      status.status = StatusCode::FAILURE;
      status.createdEvents = m_nLocalCreatedEvts;
      status.skippedEvents = m_nLocalSkippedEvts;
      status.finishedEvents = m_nLocalFinishedEvts;
      m_clusterSvc->sendMessage(
          0, ClusterMessage(ClusterMessageType::WorkerError, status));
      return StatusCode::FAILURE;
    }
 
    int evt = get<int>(msg.payload);
    ATH_MSG_INFO("Starting event {}", evt);
    StatusCode sc = insertEvent(
        evt, end_of_stream,
        std::chrono::duration_cast<std::chrono::nanoseconds>(request_time)
            .count());
    if (sc.isFailure() && !sc.isRecoverable()) {
      ClusterMessage::WorkerStatus status{};
      status.status = sc;
      status.createdEvents = m_nLocalCreatedEvts;
      status.skippedEvents = m_nLocalSkippedEvts;
      status.finishedEvents = m_nLocalFinishedEvts;
      m_clusterSvc->sendMessage(
          0, ClusterMessage(ClusterMessageType::WorkerError, status));
      return sc;
    }
    if (end_of_stream || m_terminateLoop) {
      auto loop_time = Clock::now() - start;
      ATH_MSG_INFO("Worker {} DONE. Loop took  to process  events.",
                   m_clusterSvc->rank(),
                   std::chrono::hh_mm_ss(loop_time),
                   m_nLocalCreatedEvts);
      // reached end of stream, drain scheduler
      ClusterMessage::WorkerStatus status{};
      // At end of stream, we need to *fully* drain the scheduler
      StatusCode sc = StatusCode::SUCCESS;
      std::size_t numSlots = m_whiteboard->getNumberOfStores();
      while (sc.isSuccess() && m_schedulerSvc->freeSlots() < numSlots) {
        sc = drainLocalScheduler();
      }
      status.status = sc;
      status.createdEvents = m_nLocalCreatedEvts;
      status.skippedEvents = m_nLocalSkippedEvts;
      status.finishedEvents = m_nLocalFinishedEvts;
      m_clusterSvc->sendMessage(
          0, ClusterMessage(ClusterMessageType::FinalWorkerStatus, status));
      return sc;
    }
  }
}

writeHistograms()

StatusCode AthenaHiveEventLoopMgr::writeHistograms ( bool force = false )

protectedvirtualinherited

Dump out histograms as needed.

Definition at line 414 of file AthenaHiveEventLoopMgr.cxx.

                                                             {
 
  StatusCode sc (StatusCode::SUCCESS);
  
  if ( 0 != m_histoPersSvc && m_writeHists ) {
    std::vector<DataObject*> objects;
    sc = m_histoDataMgrSvc->traverseTree( [&objects]( IRegistry* reg, int ) {
        DataObject* obj = reg->object();
        if ( !obj || obj->clID() == CLID_StatisticsFile ) return false;
        objects.push_back( obj );
        return true;
      } );
 
    if ( !sc.isSuccess() ) {
      ATH_MSG_ERROR ( "Error while traversing Histogram data store" );
      return sc;
    }
 
    if ( objects.size() > 0) {
      int writeInterval(m_writeInterval.value());
 
      if ( m_nevt == 1 || force || 
           (writeInterval != 0 && m_nevt%writeInterval == 0) ) {
 
        // skip /stat entry!
        sc = std::accumulate( begin( objects ), end( objects ), sc, [&]( StatusCode isc, auto& i ) {
            IOpaqueAddress* pAddr = nullptr;
            StatusCode      iret  = m_histoPersSvc->createRep( i, pAddr );
            if ( iret.isFailure() ) return iret;
            i->registry()->setAddress( pAddr );
            return isc;
          } );
        sc = std::accumulate( begin( objects ), end( objects ), sc, [&]( StatusCode isc, auto& i ) {
            IRegistry* reg  = i->registry();
            StatusCode iret = m_histoPersSvc->fillRepRefs( reg->address(), i );
            return iret.isFailure() ? iret : isc;
          } );
        if ( ! sc.isSuccess() ) {
          ATH_MSG_ERROR ( "Error while saving Histograms." );
        }
      }
 
      if (force || (writeInterval != 0 && m_nevt%writeInterval == 0) ) {
        ATH_MSG_DEBUG ( "committing Histograms" );
        m_histoPersSvc->conversionSvc()->commitOutput("",true).ignore();
      }
    }
          
  }
  
  return sc;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_abortEventListener

SmartIF< IIncidentListener > AthenaHiveEventLoopMgr::m_abortEventListener

protectedinherited

Instance of the incident listener waiting for AbortEvent.

Definition at line 176 of file AthenaHiveEventLoopMgr.h.

m_aess

SmartIF<IAlgExecStateSvc> AthenaHiveEventLoopMgr::m_aess

protectedinherited

Reference to the Algorithm Execution State Svc.

Definition at line 160 of file AthenaHiveEventLoopMgr.h.

m_algResourcePool

SmartIF<IAlgResourcePool> AthenaHiveEventLoopMgr::m_algResourcePool

protectedinherited

Reference to the Algorithm resource pool.

Definition at line 157 of file AthenaHiveEventLoopMgr.h.

m_appMgrProperty

SmartIF<IProperty> AthenaHiveEventLoopMgr::m_appMgrProperty

protectedinherited

Property interface of ApplicationMgr.

Definition at line 163 of file AthenaHiveEventLoopMgr.h.

m_clusterSvc

ServiceHandle<IMPIClusterSvc> MPIHiveEventLoopMgr::m_clusterSvc

protected

Initial value:

{this, "MPIClusterSvc", "",
                                             "MPIClusterSvc"}

Reference to the MPIClusterSvc.

Definition at line 38 of file MPIHiveEventLoopMgr.h.

                                            {this, "MPIClusterSvc", "",
                                             "MPIClusterSvc"};

m_conditionsCleaner

ServiceHandle<Athena::IConditionsCleanerSvc> AthenaHiveEventLoopMgr::m_conditionsCleaner

privateinherited

Definition at line 270 of file AthenaHiveEventLoopMgr.h.

m_contiguousFailedEvts

int MPIHiveEventLoopMgr::m_contiguousFailedEvts {0}

protected

Definition at line 52 of file MPIHiveEventLoopMgr.h.

{0};

m_currentRun

number_type AthenaHiveEventLoopMgr::m_currentRun

protectedinherited

current run number

Definition at line 109 of file AthenaHiveEventLoopMgr.h.

m_doEvtHeartbeat

bool AthenaHiveEventLoopMgr::m_doEvtHeartbeat

protectedinherited

Definition at line 251 of file AthenaHiveEventLoopMgr.h.

m_eventPrintoutInterval

UnsignedIntegerProperty AthenaHiveEventLoopMgr::m_eventPrintoutInterval

protectedinherited

Definition at line 116 of file AthenaHiveEventLoopMgr.h.

m_eventStore

StoreGateSvc_t AthenaHiveEventLoopMgr::m_eventStore

protectedinherited

Reference to StoreGateSvc;.

Property

Definition at line 83 of file AthenaHiveEventLoopMgr.h.

m_evtContext

EvtContext* AthenaHiveEventLoopMgr::m_evtContext

protectedinherited

Gaudi event selector Context (may be used as a cursor by the evt selector).

Definition at line 88 of file AthenaHiveEventLoopMgr.h.

m_evtIdModSvc

IEvtIdModifierSvc_t AthenaHiveEventLoopMgr::m_evtIdModSvc

protectedinherited

Definition at line 102 of file AthenaHiveEventLoopMgr.h.

m_evtsel

StringProperty AthenaHiveEventLoopMgr::m_evtsel

protectedinherited

Definition at line 90 of file AthenaHiveEventLoopMgr.h.

m_evtSelector

IEvtSelector* AthenaHiveEventLoopMgr::m_evtSelector

protectedinherited

Reference to the Event Selector.

Definition at line 86 of file AthenaHiveEventLoopMgr.h.

m_evtSelectorCurrentPos

int MPIHiveEventLoopMgr::m_evtSelectorCurrentPos = 0

private

Definition at line 75 of file MPIHiveEventLoopMgr.h.

m_failureMode

IntegerProperty AthenaHiveEventLoopMgr::m_failureMode

protectedinherited

Definition at line 113 of file AthenaHiveEventLoopMgr.h.

m_firstEventAlone

bool AthenaHiveEventLoopMgr::m_firstEventAlone

privateinherited

Definition at line 258 of file AthenaHiveEventLoopMgr.h.

m_firstEventIndex

UnsignedIntegerProperty MPIHiveEventLoopMgr::m_firstEventIndex

private

Initial value:

{
      this, "FirstEventIndex", 0, "First event index (Exec.SkipEvents)"}

Definition at line 73 of file MPIHiveEventLoopMgr.h.

                                           {
      this, "FirstEventIndex", 0, "First event index (Exec.SkipEvents)"};

m_firstRun

bool AthenaHiveEventLoopMgr::m_firstRun

protectedinherited

Definition at line 110 of file AthenaHiveEventLoopMgr.h.

m_flmbi

unsigned int AthenaHiveEventLoopMgr::m_flmbi

privateinherited

Definition at line 260 of file AthenaHiveEventLoopMgr.h.

m_histoDataMgrSvc

IDataManagerSvc_t AthenaHiveEventLoopMgr::m_histoDataMgrSvc

protectedinherited

Reference to the Histogram Data Service.

Definition at line 94 of file AthenaHiveEventLoopMgr.h.

m_histoPersSvc

IConversionSvc_t AthenaHiveEventLoopMgr::m_histoPersSvc

protectedinherited

Definition at line 98 of file AthenaHiveEventLoopMgr.h.

m_histPersName

StringProperty AthenaHiveEventLoopMgr::m_histPersName

protectedinherited

Definition at line 105 of file AthenaHiveEventLoopMgr.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_incidentSvc

IIncidentSvc_t AthenaHiveEventLoopMgr::m_incidentSvc

protectedinherited

Reference to the incident service.

Definition at line 79 of file AthenaHiveEventLoopMgr.h.

m_lastEventContext

EventContext AthenaHiveEventLoopMgr::m_lastEventContext

protectedinherited

Definition at line 255 of file AthenaHiveEventLoopMgr.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nev

unsigned int AthenaHiveEventLoopMgr::m_nev

protectedinherited

events processed

Definition at line 248 of file AthenaHiveEventLoopMgr.h.

m_nevt

unsigned int AthenaHiveEventLoopMgr::m_nevt

privateinherited

Definition at line 237 of file AthenaHiveEventLoopMgr.h.

m_nLocalCreatedEvts

int MPIHiveEventLoopMgr::m_nLocalCreatedEvts {0}

protected

Definition at line 55 of file MPIHiveEventLoopMgr.h.

{0};

m_nLocalFinishedEvts

int MPIHiveEventLoopMgr::m_nLocalFinishedEvts {0}

protected

Definition at line 57 of file MPIHiveEventLoopMgr.h.

{0};

m_nLocalSkippedEvts

int MPIHiveEventLoopMgr::m_nLocalSkippedEvts {0}

protected

Definition at line 56 of file MPIHiveEventLoopMgr.h.

{0};

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_proc

unsigned int AthenaHiveEventLoopMgr::m_proc

protectedinherited

Definition at line 249 of file AthenaHiveEventLoopMgr.h.

m_requireInputAttributeList

bool AthenaHiveEventLoopMgr::m_requireInputAttributeList {}

protectedinherited

require input attribute list

Definition at line 134 of file AthenaHiveEventLoopMgr.h.

{};

m_scheduledStop

bool AthenaHiveEventLoopMgr::m_scheduledStop

protectedinherited

Scheduled stop of event processing.

Definition at line 182 of file AthenaHiveEventLoopMgr.h.

m_schedulerName

std::string AthenaHiveEventLoopMgr::m_schedulerName

protectedinherited

Name of the scheduler to be used.

Definition at line 178 of file AthenaHiveEventLoopMgr.h.

m_schedulerSvc

SmartIF<IScheduler> AthenaHiveEventLoopMgr::m_schedulerSvc

protectedinherited

A shortcut for the scheduler.

Definition at line 166 of file AthenaHiveEventLoopMgr.h.

m_terminateLoop

bool AthenaHiveEventLoopMgr::m_terminateLoop { false }

protectedinherited

Definition at line 246 of file AthenaHiveEventLoopMgr.h.

{ false };

m_timeStamp

unsigned int AthenaHiveEventLoopMgr::m_timeStamp { 0 }

privateinherited

Definition at line 238 of file AthenaHiveEventLoopMgr.h.

{ 0 };

m_timeStampInt

unsigned int AthenaHiveEventLoopMgr::m_timeStampInt

privateinherited

Definition at line 260 of file AthenaHiveEventLoopMgr.h.

m_toolAccept

tool_stats AthenaHiveEventLoopMgr::m_toolAccept

protectedinherited

tool returns StatusCode::SUCCESS counter

Definition at line 127 of file AthenaHiveEventLoopMgr.h.

m_toolInvoke

tool_stats AthenaHiveEventLoopMgr::m_toolInvoke

protectedinherited

tool called counter

Definition at line 125 of file AthenaHiveEventLoopMgr.h.

m_toolReject

tool_stats AthenaHiveEventLoopMgr::m_toolReject

protectedinherited

tool returns StatusCode::FAILURE counter

Definition at line 126 of file AthenaHiveEventLoopMgr.h.

m_tools

tool_store AthenaHiveEventLoopMgr::m_tools

protectedinherited

internal tool store

Definition at line 128 of file AthenaHiveEventLoopMgr.h.

m_totalFailedEvts

int MPIHiveEventLoopMgr::m_totalFailedEvts {0}

protected

Definition at line 53 of file MPIHiveEventLoopMgr.h.

{0};

m_useSecondaryEventNumber

bool AthenaHiveEventLoopMgr::m_useSecondaryEventNumber {}

protectedinherited

read event number from secondary input

Definition at line 137 of file AthenaHiveEventLoopMgr.h.

{};

m_useTools

bool AthenaHiveEventLoopMgr::m_useTools

protectedinherited

Definition at line 250 of file AthenaHiveEventLoopMgr.h.

m_whiteboard

SmartIF<IHiveWhiteBoard> AthenaHiveEventLoopMgr::m_whiteboard

protectedinherited

Reference to the Whiteboard interface.

Definition at line 154 of file AthenaHiveEventLoopMgr.h.

m_whiteboardName

std::string AthenaHiveEventLoopMgr::m_whiteboardName

protectedinherited

Name of the Whiteboard to be used.

Definition at line 180 of file AthenaHiveEventLoopMgr.h.

m_writeHists

bool AthenaHiveEventLoopMgr::m_writeHists

privateinherited

Definition at line 241 of file AthenaHiveEventLoopMgr.h.

m_writeInterval

UnsignedIntegerProperty AthenaHiveEventLoopMgr::m_writeInterval

privateinherited

Definition at line 240 of file AthenaHiveEventLoopMgr.h.

---

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

• MPIHiveEventLoopMgr.h
• MPIHiveEventLoopMgr.cxx