HltEventLoopMgr Class Reference

AthenaMT event loop manager for running HLT online. More...

#include <HltEventLoopMgr.h>

Inheritance diagram for HltEventLoopMgr:

Collaboration diagram for HltEventLoopMgr:

Classes
struct	EventLoopStatus
	Flags and counters steering the main event loop execution. More...

Public Member Functions
	HltEventLoopMgr (const std::string &name, ISvcLocator *svcLoc)
	Standard constructor. More...
virtual	~HltEventLoopMgr () noexcept override
	Standard destructor. More...
	HltEventLoopMgr (const HltEventLoopMgr &)=delete
	HltEventLoopMgr (HltEventLoopMgr &&)=delete
HltEventLoopMgr &	operator= (const HltEventLoopMgr &)=delete
HltEventLoopMgr &	operator= (HltEventLoopMgr &&)=delete
virtual StatusCode	executeRun (int maxevt=-1) override
	Implementation of IEventProcessor::executeRun which calls IEventProcessor::nextEvent. More...
virtual StatusCode	nextEvent (int maxevt=-1) override
	Implementation of IEventProcessor::nextEvent which implements the event loop. More...
virtual StatusCode	executeEvent (EventContext &&ctx) override
	Implementation of IEventProcessor::executeEvent which processes a single event. More...
virtual EventContext	createEventContext () override
	create an Event Context object More...
virtual StatusCode	stopRun () override
	Implementation of IEventProcessor::stopRun (obsolete for online runnning) More...
Gaudi state transitions (overriden from AthService)
virtual StatusCode	initialize () override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
State transitions of ITrigEventLoopMgr interface
virtual StatusCode	prepareForStart (const boost::property_tree::ptree &) override
virtual StatusCode prepareForRun	ATLAS_NOT_THREAD_SAFE (const boost::property_tree::ptree &pt) override
virtual StatusCode	hltUpdateAfterFork (const boost::property_tree::ptree &pt) override

Protected Member Functions
void	setTimeout (Timeout &instance)
	Set timeout. More...
void	resetTimeout (Timeout &instance)
	Reset timeout. More...

Private Member Functions
void	updateDFProps ()
	Read DataFlow configuration properties. More...
void	updateMetadataStore (const coral::AttributeList &sor_attrlist) const
StatusCode	updateMagField (const boost::property_tree::ptree &pt) const
	Set magnetic field currents from ptree. More...
StatusCode	clearTemporaryStores ()
	Clear per-event stores. More...
const coral::AttributeList &	getSorAttrList () const
	Extract the single attr list off the SOR CondAttrListCollection. More...
void	printSORAttrList (const coral::AttributeList &atr) const
	Print the SOR record. More...
StatusCode	execAtStart (const EventContext &ctx) const
	Execute optional algs/sequences. More...
StatusCode	failedEvent (HLT::OnlineErrorCode errorCode, const EventContext &eventContext)
	Handle a failure to process an event. More...
void	resetEventTimer (const EventContext &eventContext, bool processing)
	Reset the timeout flag and the timer, and mark the slot as busy or idle according to the second argument. More...
StatusCode	clearWBSlot (size_t evtSlot) const
	Clear an event slot in the whiteboard. More...
Methods executed by LoopThreads
The method executed by the input handling thread
void	inputThreadCallback ()
void	outputThreadCallback ()
	The method executed by the output handling thread. More...
void	eventTimerCallback ()
	The method executed by the event timeout monitoring thread. More...
Methods executed by TBB tasks
Perform all start-of-event actions for a single new event and push it to the scheduler
StatusCode	startNextEvent ()
StatusCode	processFinishedEvent ()
	Perform all end-of-event actions for a single event popped out from the scheduler. More...

Private Attributes
ServiceHandle< IIncidentSvc >	m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
ServiceHandle< Gaudi::Interfaces::IOptionsSvc >	m_jobOptionsSvc {this, "JobOptionsSvc", "JobOptionsSvc"}
ServiceHandle< StoreGateSvc >	m_evtStore {this, "EventStore", "StoreGateSvc"}
ServiceHandle< StoreGateSvc >	m_detectorStore {this, "DetectorStore", "DetectorStore"}
ServiceHandle< StoreGateSvc >	m_inputMetaDataStore {this, "InputMetaDataStore", "StoreGateSvc/InputMetaDataStore"}
ServiceHandle< IIoComponentMgr >	m_ioCompMgr {this, "IoComponentMgr", "IoComponentMgr"}
ServiceHandle< IEvtSelector >	m_evtSelector {this, "EvtSel", "EvtSel"}
ServiceHandle< IConversionSvc >	m_outputCnvSvc {this, "OutputCnvSvc", "OutputCnvSvc"}
ServiceHandle< ISchedulerMonSvc >	m_schedulerMonSvc {this, "SchedulerMonSvc", "SchedulerMonSvc"}
ToolHandle< TrigCOOLUpdateHelper >	m_coolHelper {this, "CoolUpdateTool", "TrigCOOLUpdateHelper"}
ToolHandle< HLTResultMTMaker >	m_hltResultMaker {this, "ResultMaker", "HLTResultMTMaker"}
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool"}
ToolHandle< ITrigErrorMonTool >	m_errorMonTool {this, "TrigErrorMonTool", "TrigErrorMonTool", "Error monitoring tool"}
SmartIF< IHiveWhiteBoard >	m_whiteboard
SmartIF< IAlgResourcePool >	m_algResourcePool
SmartIF< IAlgExecStateSvc >	m_aess
SmartIF< IScheduler >	m_schedulerSvc
std::unique_ptr< TrigSORFromPtreeHelper >	m_sorHelper
Gaudi::Property< std::string >	m_schedulerName
Gaudi::Property< std::string >	m_whiteboardName
Gaudi::Property< float >	m_hardTimeout
Gaudi::Property< float >	m_softTimeoutFraction
Gaudi::Property< unsigned int >	m_timeoutThreadIntervalMs
Gaudi::Property< bool >	m_traceOnTimeout
Gaudi::Property< int >	m_maxParallelIOTasks
Gaudi::Property< int >	m_maxIOWakeUpIntervalMs
Gaudi::Property< int >	m_maxFrameworkErrors
Gaudi::Property< std::string >	m_fwkErrorDebugStreamName
Gaudi::Property< std::string >	m_algErrorDebugStreamName
Gaudi::Property< std::string >	m_timeoutDebugStreamName
Gaudi::Property< std::string >	m_truncationDebugStreamName
Gaudi::Property< std::string >	m_sorPath
Gaudi::Property< std::vector< std::string > >	m_execAtStart
Gaudi::Property< bool >	m_setMagFieldFromPtree
Gaudi::Property< unsigned int >	m_forceRunNumber
Gaudi::Property< unsigned int >	m_forceLumiblock
Gaudi::Property< unsigned long long >	m_forceSOR_ns
Gaudi::Property< bool >	m_rewriteLVL1
Gaudi::Property< bool >	m_monitorScheduler
SG::WriteHandleKey< EventContext >	m_eventContextWHKey
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoRHKey
SG::ReadHandleKey< xAOD::TrigCompositeContainer >	m_l1TriggerResultRHKey
SG::ReadHandleKey< ROIB::RoIBResult >	m_roibResultRHKey
SG::ReadHandleKey< HLT::HLTResultMT >	m_hltResultRHKey
	StoreGate key for reading the HLT result. More...
EventContext	m_currentRunCtx {0,0}
	"Event" context of current run with dummy event/slot number More...
std::atomic< size_t >	m_localEventNumber {0}
	Event counter used for local bookkeeping; incremental per instance of HltEventLoopMgr, unrelated to global_id. More...
IEvtSelector::Context *	m_evtSelContext {nullptr}
	Event selector context. More...
std::vector< std::chrono::steady_clock::time_point >	m_eventTimerStartPoint
	Vector of event start-processing time stamps in each slot. More...
std::vector< std::chrono::steady_clock::time_point >	m_freeSlotStartPoint
	Vector of time stamps telling when each scheduler slot was freed. More...
std::vector< bool >	m_isSlotProcessing
	Vector of flags to tell if a slot is idle or processing. More...
std::atomic< size_t >	m_freeSlots {0}
	Number of free slots used to synchronise input/output tasks. More...
std::unique_ptr< HLT::LoopThread >	m_inputThread
	Input handling thread (triggers reading new events) More...
std::unique_ptr< HLT::LoopThread >	m_outputThread
	Output handling thread (triggers post-processing of finished events) More...
std::unique_ptr< HLT::LoopThread >	m_timeoutThread
	Timeout thread. More...
std::chrono::milliseconds	m_softTimeoutValue {0}
	Soft timeout value set to HardTimeout*SoftTimeoutFraction at initialisation. More...
tbb::task_group	m_parallelIOTaskGroup
	Task group to execute parallel I/O tasks asynchronously. More...
tbb::concurrent_bounded_queue< bool >	m_parallelIOQueue
	Queue limiting the number of parallel I/O tasks. More...
tbb::concurrent_bounded_queue< EventContext * >	m_finishedEventsQueue
	Queue of events ready for output processing. More...
EventLoopStatus	m_loopStatus {}
	Object keeping track of the event loop status. More...
bool	m_timeoutTraceGenerated {false}
	Flag set when a soft timeout produces a stack trace, to avoid producing multiple traces. More...
std::atomic< int >	m_nFrameworkErrors {0}
	Counter of framework errors. More...
std::string	m_applicationName
	Application name. More...
int	m_workerID {0}
	Worker ID. More...
int	m_workerPID {0}
	Worker PID. More...

Detailed Description

AthenaMT event loop manager for running HLT online.

Definition at line 71 of file HltEventLoopMgr.h.

Constructor & Destructor Documentation

HltEventLoopMgr() [1/3]

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

Standard constructor.

Definition at line 68 of file HltEventLoopMgr.cxx.

: base_class(name, svcLoc) {}

~HltEventLoopMgr()

HltEventLoopMgr::~HltEventLoopMgr ( )

overridevirtualnoexcept

Standard destructor.

Definition at line 74 of file HltEventLoopMgr.cxx.

{
  // tbb:task_group destructor throws if wait() was never called
  m_parallelIOTaskGroup.wait();
}

HltEventLoopMgr() [2/3]

HltEventLoopMgr::HltEventLoopMgr ( const HltEventLoopMgr &  )

delete

HltEventLoopMgr() [3/3]

HltEventLoopMgr::HltEventLoopMgr ( HltEventLoopMgr &&  )

delete

Member Function Documentation

ATLAS_NOT_THREAD_SAFE()

virtual StatusCode prepareForRun HltEventLoopMgr::ATLAS_NOT_THREAD_SAFE ( const boost::property_tree::ptree &  pt )

overridevirtual

clearTemporaryStores()

StatusCode HltEventLoopMgr::clearTemporaryStores ( )

private

Clear per-event stores.

Definition at line 702 of file HltEventLoopMgr.cxx.

{
  //----------------------------------------------------------------------------
  // Clear the event store, if used in the event loop
  //----------------------------------------------------------------------------
  ATH_CHECK(m_evtStore->clearStore());
  ATH_MSG_DEBUG("Cleared the EventStore");
 
  //----------------------------------------------------------------------------
  // Clear the InputMetaDataStore
  //----------------------------------------------------------------------------
  ATH_CHECK(m_inputMetaDataStore->clearStore());
  ATH_MSG_DEBUG("Cleared the InputMetaDataStore");
 
  return StatusCode::SUCCESS;
}

clearWBSlot()

StatusCode HltEventLoopMgr::clearWBSlot ( size_t  evtSlot ) const

private

Clear an event slot in the whiteboard.

Definition at line 1043 of file HltEventLoopMgr.cxx.

{
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  auto monTime = Monitored::Timer<std::chrono::duration<float, std::milli>>("TIME_clearStore");
  StatusCode sc = m_whiteboard->clearStore(evtSlot);
  Monitored::Group(m_monTool, monTime);
  if( !sc.isSuccess() )  {
    ATH_MSG_WARNING("Clear of event data store failed");
  }
  ATH_MSG_VERBOSE("end of " << __FUNCTION__ << ", returning m_whiteboard->freeStore(evtSlot=" << evtSlot << ")");
  return m_whiteboard->freeStore(evtSlot);
}

createEventContext()

EventContext HltEventLoopMgr::createEventContext ( )

overridevirtual

create an Event Context object

Definition at line 578 of file HltEventLoopMgr.cxx.

                                                 {
  size_t eventNumber = ++m_localEventNumber;
  auto slot = m_whiteboard->allocateStore(eventNumber); // returns npos on failure
  if (slot == std::string::npos) {
    // return an invalid EventContext
    return EventContext();
  }
  return EventContext{ eventNumber, slot };
}

eventTimerCallback()

void HltEventLoopMgr::eventTimerCallback ( )

private

The method executed by the event timeout monitoring thread.

Definition at line 1004 of file HltEventLoopMgr.cxx.

{
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  auto now=std::chrono::steady_clock::now();
  for (size_t i=0; i<m_eventTimerStartPoint.size(); ++i) {
    // iterate over all slots and check for timeout
    if (!m_isSlotProcessing.at(i)) continue;
    if (now > m_eventTimerStartPoint.at(i) + m_softTimeoutValue) {
      EventContext ctx(0,i); // we only need the slot number for Athena::Timeout instance
      // don't duplicate the actions if the timeout was already reached
      if (!Athena::Timeout::instance(ctx).reached()) {
        ATH_MSG_ERROR("Soft timeout in slot " << i << ". Processing time exceeded the limit of " << m_softTimeoutValue.count() << " ms");
        setTimeout(Athena::Timeout::instance(ctx));
        // Generate stack trace and scheduler dump only once, on the first timeout
        if (m_traceOnTimeout.value() && !m_timeoutTraceGenerated) {
          m_schedulerSvc->dumpState();
          ATH_MSG_INFO("Generating stack trace due to the soft timeout");
          m_timeoutTraceGenerated = true;
          gSystem->StackTrace();
        }
      }
    }
  }
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
}

execAtStart()

StatusCode HltEventLoopMgr::execAtStart ( const EventContext &  ctx ) const

private

Execute optional algs/sequences.

Definition at line 393 of file HltEventLoopMgr.cxx.

{
  const IAlgManager* algMgr = Gaudi::svcLocator()->as<IAlgManager>();
  IAlgorithm* alg{nullptr};
 
  StatusCode sc;
  for (const std::string& name : m_execAtStart) {
    if ( algMgr->getAlgorithm(name, alg) ) {
      ATH_MSG_INFO("Executing " << alg->name() << "...");
      sc &= alg->sysExecute(ctx);
    }
    else ATH_MSG_WARNING("Cannot find algorithm or sequence " << name);
  }
  return sc;
}

executeEvent()

StatusCode HltEventLoopMgr::executeEvent ( EventContext &&  ctx )

overridevirtual

Implementation of IEventProcessor::executeEvent which processes a single event.

Parameters

ctx	the EventContext of the event to process

Definition at line 591 of file HltEventLoopMgr.cxx.

{
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  resetTimeout(Athena::Timeout::instance(ctx));
 
  // Monitor slot idle time (between scheduler popFinishedEvent and pushNewEvent)
  // Note this is time of a scheduler slot being free, not equal to the time of a whiteboard slot being free
  const auto slotIdleTime = std::chrono::steady_clock::now() - m_freeSlotStartPoint[ctx.slot()];
  Monitored::Scalar<int64_t> monSlotIdleTime("SlotIdleTime", std::chrono::duration_cast<std::chrono::milliseconds>(slotIdleTime).count());
  Monitored::Group(m_monTool, monSlotIdleTime);
 
  // Now add event to the scheduler
  ATH_MSG_DEBUG("Adding event " <<  ctx.evt() << ", slot " << ctx.slot() << " to the scheduler");
  StatusCode addEventStatus = m_schedulerSvc->pushNewEvent( new EventContext{std::move(ctx)} );
 
  // If this fails, we need to wait for something to complete
  if (addEventStatus.isFailure()){
    ATH_MSG_ERROR("Failed adding event to the scheduler");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

executeRun()

StatusCode HltEventLoopMgr::executeRun ( int  maxevt = -1 )

overridevirtual

Implementation of IEventProcessor::executeRun which calls IEventProcessor::nextEvent.

Parameters

maxevt

number of events to process, -1 means all

Definition at line 494 of file HltEventLoopMgr.cxx.

{
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  if (m_monitorScheduler) ATH_CHECK(m_schedulerMonSvc->startMonitoring());
 
  StatusCode sc = StatusCode::SUCCESS;
  try {
    sc = nextEvent(maxevt);
    if (sc.isFailure()) ATH_MSG_FATAL("Event loop failed");
  }
  catch (const std::exception& e) {
    ATH_MSG_FATAL("Event loop failed, std::exception caught: " << e.what());
    sc = StatusCode::FAILURE;
  }
  catch (...) {
    ATH_MSG_FATAL("Event loop failed, unknown exception caught");
    sc = StatusCode::FAILURE;
  }
 
  if (m_monitorScheduler) ATH_CHECK(m_schedulerMonSvc->stopMonitoring());
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return sc;
}

failedEvent()

StatusCode HltEventLoopMgr::failedEvent ( HLT::OnlineErrorCode  errorCode, const EventContext &  eventContext  )

private

Handle a failure to process an event.

Returns

FAILURE means the event loop was flagged to stop (no new events will be requested)

Definition at line 766 of file HltEventLoopMgr.cxx.

{
  ATH_MSG_VERBOSE("start of " << __FUNCTION__ << " with errorCode = " << errorCode
                  << ", context = " << eventContext << " eventID = " << eventContext.eventID());
 
  // Used by MsgSvc (and possibly others but not relevant here)
  Gaudi::Hive::setCurrentContext(eventContext);
 
  auto returnFailureAndStopEventLoop = [this]() -> StatusCode {
    ATH_MSG_INFO("Stopping event loop due to failure");
    // Change the loop exit code to FAILURE
    m_loopStatus.exitCode = StatusCode::FAILURE;
 
    // Flag eventsAvailable=false which will result in I/O threads to finish all the ongoing event processing
    // and then stop. We cannot flag loopEnded=true here yet, because it would finish the I/O threads while
    // there might be still events being processed and they would crash when finished.
    m_loopStatus.eventsAvailable = false;
 
    // Inform the caller the failure could not be handled cleanly and the event loop will stop
    return StatusCode::FAILURE;
  };
 
  //----------------------------------------------------------------------------
  // Handle framework errors by printing an informative message and breaking the loop
  //----------------------------------------------------------------------------
  if (errorCode==HLT::OnlineErrorCode::BEFORE_NEXT_EVENT) {
    ATH_MSG_ERROR("Failure occurred with OnlineErrorCode=" << errorCode
      << " meaning there was a framework error before requesting a new event. No output will be produced for this event"
      << " and the event loop will exit after all ongoing processing is finished.");
    return returnFailureAndStopEventLoop();
  }
  if (errorCode==HLT::OnlineErrorCode::CANNOT_RETRIEVE_EVENT) {
    ATH_MSG_ERROR("Failure occurred with OnlineErrorCode=" << errorCode
      << " meaning a new event could not be correctly read. No output will be produced for this event."
      << " The event loop will exit after all ongoing processing is finished.");
    return returnFailureAndStopEventLoop();
  }
  if (errorCode==HLT::OnlineErrorCode::AFTER_RESULT_SENT) {
    ATH_MSG_ERROR("Failure occurred with OnlineErrorCode=" << errorCode
      << " meaning there was a framework error after HLT result was already sent out."
      << " The event loop will exit after all ongoing processing is finished.");
    return returnFailureAndStopEventLoop();
  }
  if (errorCode==HLT::OnlineErrorCode::CANNOT_ACCESS_SLOT) {
    ATH_MSG_ERROR("Failed to access the slot for the processed event, cannot produce output. OnlineErrorCode="
      << errorCode << ". The event loop will exit after all ongoing processing is finished unless the failed event"
      << " reaches a hard timeout sooner and this process is killed.");
    return returnFailureAndStopEventLoop();
  }
  if (errorCode==HLT::OnlineErrorCode::SCHEDULING_FAILURE) {
    // Here we cannot be certain if the scheduler started processing the event or not. If yes, the output thread
    // will finalise the event as normal. If not, the event will eventually reach a hard timeout and this process
    // is killed, or we exit the process without ever producing output for this event (needs to be handled upstream).
    ATH_MSG_ERROR("Failure occurred with OnlineErrorCode=" << errorCode
      << ". Cannot determine if the event processing started or not and whether a decision for this event will be"
      << " produced. The event loop will exit after all ongoing processing is finished, which may include or"
      << " not include the problematic event.");
    return returnFailureAndStopEventLoop();
  }
  if (errorCode==HLT::OnlineErrorCode::SCHEDULER_POP_FAILURE) {
    ATH_MSG_ERROR("Failure occurred with OnlineErrorCode=" << errorCode
      << " meaning the Scheduler returned FAILURE when asked to give a finished event. Will keep trying to"
      << " pop further events if there are any still in the scheduler, but this may keep repeating until"
      << " this process is killed by hard timeout or other means. If all ongoing processing manages to finish"
      << " then the event loop will exit.");
    return returnFailureAndStopEventLoop();
  }
  if (!eventContext.valid()) {
    ATH_MSG_ERROR("Failure occurred with an invalid EventContext. Likely there was a framework error before"
      << " requesting a new event or after sending the result of a finished event. OnlineErrorCode=" << errorCode
      << ". The event loop will exit after all ongoing processing is finished.");
    return returnFailureAndStopEventLoop();
  }
 
  //----------------------------------------------------------------------------
  // Make sure we are using the right store
  //----------------------------------------------------------------------------
  if (m_whiteboard->selectStore(eventContext.slot()).isFailure()) {
    return failedEvent(HLT::OnlineErrorCode::CANNOT_ACCESS_SLOT,eventContext);
  }
 
  //----------------------------------------------------------------------------
  // Define a debug stream tag for the HLT result
  //----------------------------------------------------------------------------
  std::string debugStreamName;
  switch (errorCode) {
    case HLT::OnlineErrorCode::PROCESSING_FAILURE:
      debugStreamName = m_algErrorDebugStreamName.value();
      break;
    case HLT::OnlineErrorCode::TIMEOUT:
      debugStreamName = m_timeoutDebugStreamName.value();
      break;
    case HLT::OnlineErrorCode::RESULT_TRUNCATION:
      debugStreamName = m_truncationDebugStreamName.value();
      break;
    default:
      debugStreamName = m_fwkErrorDebugStreamName.value();
      break;
  }
  eformat::helper::StreamTag debugStreamTag{debugStreamName, eformat::DEBUG_TAG, true};
 
  //----------------------------------------------------------------------------
  // Create an HLT result for the failed event (copy one if it exists and contains serialised data)
  //----------------------------------------------------------------------------
  std::unique_ptr<HLT::HLTResultMT> hltResultPtr;
  StatusCode buildResultCode{StatusCode::SUCCESS};
  auto hltResultRH = SG::makeHandle(m_hltResultRHKey,eventContext);
  if (hltResultRH.isValid() && !hltResultRH->getSerialisedData().empty()) {
    // There is already an existing result, create a copy with the error code and stream tag
    hltResultPtr = std::make_unique<HLT::HLTResultMT>(*hltResultRH);
    hltResultPtr->addErrorCode(errorCode);
    buildResultCode &= hltResultPtr->addStreamTag(debugStreamTag);
  } else {
    // Create a result if not available, pre-fill with error code an stream tag, then try to fill event data
    hltResultPtr = std::make_unique<HLT::HLTResultMT>();
    hltResultPtr->addErrorCode(errorCode);
    buildResultCode &= hltResultPtr->addStreamTag(debugStreamTag);
    // Fill the result unless we already failed doing this before
    if (errorCode != HLT::OnlineErrorCode::NO_HLT_RESULT) {
      buildResultCode &= m_hltResultMaker->fillResult(*hltResultPtr,eventContext);
    }
  }
 
  // Try to record the result in th event store
  SG::WriteHandleKey<HLT::HLTResultMT> hltResultWHK(m_hltResultRHKey.key()+"_FailedEvent");
  buildResultCode &= hltResultWHK.initialize();
  auto hltResultWH = SG::makeHandle(hltResultWHK,eventContext);
  if (buildResultCode.isFailure() || hltResultWH.record(std::move(hltResultPtr)).isFailure()) {
    if (errorCode == HLT::OnlineErrorCode::NO_HLT_RESULT) {
      // Avoid infinite loop
      ATH_MSG_ERROR("Second failure to build or record the HLT Result in event store while handling a failed event. "
                    << "Cannot force-accept this event from HLT side, will rely on data collector to do this. "
                    << "The event loop will exit after all ongoing processing is finished.");
      return returnFailureAndStopEventLoop();
    }
    ATH_MSG_ERROR("Failed to build or record the HLT Result in event store while handling a failed event. "
                  << "Trying again with skipped filling of the result contents (except debug stream tag).");
    return failedEvent(HLT::OnlineErrorCode::NO_HLT_RESULT,eventContext);
  }
 
  //----------------------------------------------------------------------------
  // Monitor event processing time for the failed (force-accepted) event
  //----------------------------------------------------------------------------
  auto eventTime = std::chrono::steady_clock::now() - m_eventTimerStartPoint[eventContext.slot()];
  int64_t eventTimeMillisec = std::chrono::duration_cast<std::chrono::milliseconds>(eventTime).count();
  auto monTimeAny = Monitored::Scalar<int64_t>("TotalTime", eventTimeMillisec);
  auto monTimeAcc = Monitored::Scalar<int64_t>("TotalTimeAccepted", eventTimeMillisec);
  Monitored::Group(m_monTool, monTimeAny, monTimeAcc);
 
  //----------------------------------------------------------------------------
  // Try to build and send the output
  //----------------------------------------------------------------------------
  if (m_outputCnvSvc->connectOutput("").isFailure()) {
    ATH_MSG_ERROR("The output conversion service failed in connectOutput() while handling a failed event. "
                  << "Cannot force-accept this event from HLT side, will rely on data collector to do this. "
                  << "The event loop will exit after all ongoing processing is finished.");
    return returnFailureAndStopEventLoop();
  }
 
  DataObject* hltResultDO = m_evtStore->accessData(hltResultWH.clid(),hltResultWH.key());
  if (hltResultDO == nullptr) {
    if (errorCode == HLT::OnlineErrorCode::NO_HLT_RESULT) {
      // Avoid infinite loop
      ATH_MSG_ERROR("Second failure to build or record the HLT Result in event store while handling a failed event. "
                    << "Cannot force-accept this event from HLT side, will rely on data collector to do this. "
                    << "The event loop will exit after all ongoing processing is finished.");
      return returnFailureAndStopEventLoop();
    }
    ATH_MSG_ERROR("Failed to retrieve DataObject for the HLT result object while handling a failed event. "
                  << "Trying again with skipped filling of the result contents (except debug stream tag).");
    return failedEvent(HLT::OnlineErrorCode::NO_HLT_RESULT,eventContext);
  }
 
  IOpaqueAddress* addr = nullptr;
  if (m_outputCnvSvc->createRep(hltResultDO,addr).isFailure() || addr == nullptr) {
    ATH_MSG_ERROR("Conversion of HLT result object to the output format failed while handling a failed event. "
                  << "Cannot force-accept this event from HLT side, will rely on data collector to do this. "
                  << "The event loop will exit after all ongoing processing is finished.");
    delete addr;
    return returnFailureAndStopEventLoop();
  }
 
  if (m_outputCnvSvc->commitOutput("",true).isFailure()) {
    ATH_MSG_ERROR("The output conversion service failed in commitOutput() while handling a failed event. "
                  << "Cannot force-accept this event from HLT side, will rely on data collector to do this. "
                  << "The event loop will exit after all ongoing processing is finished.");
    delete addr;
    return returnFailureAndStopEventLoop();
  }
 
  // The output has been sent out, the ByteStreamAddress can be deleted
  delete addr;
 
  //------------------------------------------------------------------------
  // Reset the timeout flag and the timer, and mark the slot as idle
  //------------------------------------------------------------------------
  resetEventTimer(eventContext, /*processing=*/ false);
 
  //----------------------------------------------------------------------------
  // Clear the event data slot
  //----------------------------------------------------------------------------
  // Need to copy the event context because it's managed by the event store and clearWBSlot deletes it
  const EventContext eventContextCopy = eventContext;
  if (clearWBSlot(eventContext.slot()).isFailure())
    return failedEvent(HLT::OnlineErrorCode::AFTER_RESULT_SENT,eventContextCopy);
 
  // Only now after store clearing we can allow the slot to be filled again,
  // so we increment m_freeSlots and notify the input thread
  ++m_freeSlots;
  if (!m_loopStatus.loopEnded && m_inputThread!=nullptr) {
    m_inputThread->cond().notify_all();
  }
 
  //----------------------------------------------------------------------------
  // Finish handling the failed event
  //----------------------------------------------------------------------------
 
  // Unless this is an event data or algorithm processing failure, increment the number of framework failures
  if (!HLT::isEventProcessingErrorCode(errorCode)) {
    if ( m_maxFrameworkErrors.value()>=0 && ((++m_nFrameworkErrors)>m_maxFrameworkErrors.value()) ) {
      ATH_MSG_ERROR("Failure with OnlineErrorCode=" << errorCode
        << " was successfully handled, but the number of tolerable framework errors for this HltEventLoopMgr instance,"
        << " which is " << m_maxFrameworkErrors.value() << ", was exceeded. Current local event number is "
        << eventContextCopy.evt() << ", slot " << eventContextCopy.slot()
        << ". The event loop will exit after all ongoing processing is finished.");
      return returnFailureAndStopEventLoop();
    }
  }
 
  // Even if handling the failed event succeeded, print an error message with failed event details
  ATH_MSG_ERROR("Failed event with OnlineErrorCode=" << errorCode
    << " Current local event number is " << eventContextCopy.evt() << ", slot " << eventContextCopy.slot());
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS; // error handling succeeded, event loop may continue
}

finalize()

StatusCode HltEventLoopMgr::finalize ( )

overridevirtual

Definition at line 242 of file HltEventLoopMgr.cxx.

{
  ATH_MSG_INFO(" ---> HltEventLoopMgr/" << name() << " finalize ");
  // Usually (but not necessarily) corresponds to the number of processed events +1
  ATH_MSG_INFO("Total number of EventContext objects created " << m_localEventNumber);
 
  // Release all handles
  auto releaseAndCheck = [&](auto& handle, std::string_view handleType) {
    if (handle.release().isFailure())
      ATH_MSG_WARNING("finalize(): Failed to release " << handleType << " " << handle.typeAndName());
  };
  auto releaseService = [&](auto&&... args) { (releaseAndCheck(args,"service"), ...); };
  auto releaseTool = [&](auto&&... args) { (releaseAndCheck(args,"tool"), ...); };
  auto releaseSmartIF = [](auto&&... args) { (args.reset(), ...); };
 
  releaseService(m_incidentSvc,
                 m_evtStore,
                 m_detectorStore,
                 m_inputMetaDataStore,
                 m_evtSelector,
                 m_outputCnvSvc,
                 m_schedulerMonSvc);
 
  releaseTool(m_coolHelper,
              m_hltResultMaker,
              m_monTool);
 
  releaseSmartIF(m_whiteboard,
                 m_algResourcePool,
                 m_aess,
                 m_schedulerSvc);
 
  return StatusCode::SUCCESS;
}

getSorAttrList()

const coral::AttributeList & HltEventLoopMgr::getSorAttrList ( ) const

private

Extract the single attr list off the SOR CondAttrListCollection.

Definition at line 720 of file HltEventLoopMgr.cxx.

{
  auto sor = m_detectorStore->retrieve<const TrigSORFromPtreeHelper::SOR>(m_sorPath);
  if (sor==nullptr) {
    throw std::runtime_error("Cannot retrieve " + m_sorPath);
  }
  if(sor->size() != 1)
  {
    // This branch should never be entered (the CondAttrListCollection
    // corresponding to the SOR should contain one single AttrList). Since
    // that's required by code ahead but not checked at compile time, we
    // explicitly guard against any potential future mistake with this check
    throw std::runtime_error("SOR record should have one and one only attribute list, but it has " + std::to_string(sor->size()));
  }
 
  const auto & soral = sor->begin()->second;
  printSORAttrList(soral);
  return soral;
}

hltUpdateAfterFork()

StatusCode HltEventLoopMgr::hltUpdateAfterFork ( const boost::property_tree::ptree &  pt )

overridevirtual

Definition at line 413 of file HltEventLoopMgr.cxx.

{
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  updateDFProps();
  ATH_MSG_INFO("Post-fork initialization for " << m_applicationName);
 
  ATH_MSG_DEBUG("Initialising the scheduler after forking");
  m_schedulerSvc = serviceLocator()->service(m_schedulerName, /*createIf=*/ true);
  if ( !m_schedulerSvc.isValid()){
    ATH_MSG_FATAL("Error retrieving " << m_schedulerName << " interface ISchedulerSvc");
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Initialised " << m_schedulerName << " interface ISchedulerSvc");
 
  ATH_MSG_DEBUG("Trying a stop-start of CoreDumpSvc");
  SmartIF<IService> svc = serviceLocator()->service("CoreDumpSvc", /*createIf=*/ false);
  if (svc.isValid()) {
    StatusCode sc = svc->stop();
    sc &= svc->start();
    if (sc.isFailure()) {
      ATH_MSG_WARNING("Could not perform stop/start for CoreDumpSvc");
    }
    else {
      ATH_MSG_DEBUG("Done a stop-start of CoreDumpSvc");
    }
  }
  else {
    ATH_MSG_WARNING("Could not retrieve CoreDumpSvc");
  }
 
  // Make sure output files, i.e. histograms are written to their own directory.
  // Nothing happens if the online TrigMonTHistSvc is used as there are no output files.
  SmartIF<IIoComponent> histsvc = serviceLocator()->service("THistSvc", /*createIf=*/ false).as<IIoComponent>();
  if ( !m_ioCompMgr->io_retrieve(histsvc.get()).empty() ) {
    std::filesystem::path worker_dir = std::filesystem::absolute("athenaHLT_workers");
    std::ostringstream oss;
    oss << "athenaHLT-" << std::setfill('0') << std::setw(2) << m_workerID;
    worker_dir /= oss.str();
    // Delete worker directory if it exists already
    if ( std::filesystem::exists(worker_dir) ) {
      if ( std::filesystem::remove_all(worker_dir) == 0 ) {
        ATH_MSG_FATAL("Cannot delete previous worker directory " << worker_dir);
        return StatusCode::FAILURE;
      }
    }
    if ( !std::filesystem::create_directories(worker_dir) ) {
      ATH_MSG_FATAL("Cannot create worker directory " << worker_dir);
      return StatusCode::FAILURE;
    }
    ATH_MSG_INFO("Writing worker output files to " << worker_dir);
    ATH_CHECK(m_ioCompMgr->io_update_all(worker_dir.string()));
  }
  ATH_CHECK(m_ioCompMgr->io_reinitialize());
 
  const size_t numSlots = m_whiteboard->getNumberOfStores();
  m_freeSlots = numSlots;
 
  // Initialise vector of time points for event timeout monitoring
  m_eventTimerStartPoint.clear();
  m_eventTimerStartPoint.resize(numSlots, std::chrono::steady_clock::now());
  m_isSlotProcessing.resize(numSlots, false);
 
  // Initialise vector of time points for free slots monitoring
  m_freeSlotStartPoint.clear();
  m_freeSlotStartPoint.resize(numSlots, std::chrono::steady_clock::now());
 
  // Initialise the queues used in parallel I/O steering
  m_parallelIOQueue.set_capacity(static_cast<decltype(m_parallelIOQueue)::size_type>(m_maxParallelIOTasks.value()));
  m_finishedEventsQueue.set_capacity(static_cast<decltype(m_finishedEventsQueue)::size_type>(numSlots));
 
  // Fire incident to update listeners after forking
  m_incidentSvc->fireIncident(AthenaInterprocess::UpdateAfterFork(m_workerID, m_workerPID, name(), m_currentRunCtx));
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

initialize()

StatusCode HltEventLoopMgr::initialize ( )

overridevirtual

Definition at line 83 of file HltEventLoopMgr.cxx.

{
  // Do not auto-retrieve tools (see Gaudi!1124)
  m_autoRetrieveTools = false;
  m_checkToolDeps = false;
 
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  ATH_MSG_INFO(" ---> HltEventLoopMgr = " << name() << " initialize");
 
  //----------------------------------------------------------------------------
  // Setup properties
  //----------------------------------------------------------------------------
 
  // Set the timeout value (cast float to int)
  m_softTimeoutValue = std::chrono::milliseconds(static_cast<int>(m_hardTimeout.value() * m_softTimeoutFraction.value()));
 
  // Read DataFlow configuration properties
  updateDFProps();
 
  // print properties
  ATH_MSG_INFO(" ---> ApplicationName           = " << m_applicationName);
  ATH_MSG_INFO(" ---> HardTimeout               = " << m_hardTimeout.value());
  ATH_MSG_INFO(" ---> SoftTimeoutFraction       = " << m_softTimeoutFraction.value());
  ATH_MSG_INFO(" ---> SoftTimeoutValue          = " << m_softTimeoutValue.count());
  ATH_MSG_INFO(" ---> TimeoutThreadIntervalMs   = " << m_timeoutThreadIntervalMs.value());
  ATH_MSG_INFO(" ---> TraceOnTimeout            = " << m_traceOnTimeout.value());
  ATH_MSG_INFO(" ---> MaxFrameworkErrors        = " << m_maxFrameworkErrors.value());
  ATH_MSG_INFO(" ---> FwkErrorDebugStreamName   = " << m_fwkErrorDebugStreamName.value());
  ATH_MSG_INFO(" ---> AlgErrorDebugStreamName   = " << m_algErrorDebugStreamName.value());
  ATH_MSG_INFO(" ---> TimeoutDebugStreamName    = " << m_timeoutDebugStreamName.value());
  ATH_MSG_INFO(" ---> TruncationDebugStreamName = " << m_truncationDebugStreamName.value());
  ATH_MSG_INFO(" ---> SORPath                   = " << m_sorPath.value());
  ATH_MSG_INFO(" ---> setMagFieldFromPtree      = " << m_setMagFieldFromPtree.value());
  ATH_MSG_INFO(" ---> execAtStart               = " << m_execAtStart.value());
  ATH_MSG_INFO(" ---> forceRunNumber            = " << m_forceRunNumber.value());
  ATH_MSG_INFO(" ---> forceLumiblock            = " << m_forceLumiblock.value());
  ATH_MSG_INFO(" ---> forceStartOfRunTime       = " << m_forceSOR_ns.value());
  ATH_MSG_INFO(" ---> RewriteLVL1               = " << m_rewriteLVL1.value());
  ATH_MSG_INFO(" ---> EventContextWHKey         = " << m_eventContextWHKey.key());
  ATH_MSG_INFO(" ---> EventInfoRHKey            = " << m_eventInfoRHKey.key());
 
  ATH_CHECK( m_jobOptionsSvc.retrieve() );
  const std::string& slots = m_jobOptionsSvc->get("EventDataSvc.NSlots");
  if (!slots.empty())
    ATH_MSG_INFO(" ---> NumConcurrentEvents       = " << slots);
  else
    ATH_MSG_WARNING("Failed to retrieve the job property EventDataSvc.NSlots");
  const std::string& threads = m_jobOptionsSvc->get("AvalancheSchedulerSvc.ThreadPoolSize");
  if (!threads.empty())
    ATH_MSG_INFO(" ---> NumThreads                = " << threads);
  else
    ATH_MSG_WARNING("Failed to retrieve the job property AvalancheSchedulerSvc.ThreadPoolSize");
 
  const std::string& procs = m_jobOptionsSvc->get("DataFlowConfig.DF_NumberOfWorkers");
  if (!procs.empty()) {
    ATH_MSG_INFO(" ---> NumProcs                  = " << procs);
    try {
      SG::HiveMgrSvc::setNumProcs(std::stoi(procs));
    }
    catch (const std::logic_error& ex) {
      ATH_MSG_ERROR("Cannot convert " << procs << "to integer: " << ex.what());
      return StatusCode::FAILURE;
    }
  }
  else
    ATH_MSG_WARNING("Failed to retrieve the job property DataFlowconfig.DF_NumberOfWorkers");
 
  if (m_maxParallelIOTasks.value() <= 0) {
    ATH_CHECK(m_maxParallelIOTasks.fromString(threads));
  }
  ATH_MSG_INFO(" ---> MaxParallelIOTasks        = " << m_maxParallelIOTasks.value());
  ATH_MSG_INFO(" ---> MaxIOWakeUpIntervalMs     = " << m_maxIOWakeUpIntervalMs.value());
 
  //----------------------------------------------------------------------------
  // Setup all Hive services for multithreaded event processing with the exception of SchedulerSvc,
  // which has to be initialised after forking because it opens new threads
  //----------------------------------------------------------------------------
  m_whiteboard = serviceLocator()->service(m_whiteboardName);
  if( !m_whiteboard.isValid() )  {
    ATH_MSG_FATAL("Error retrieving " << m_whiteboardName << " interface IHiveWhiteBoard");
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Initialised " << m_whiteboardName << " interface IHiveWhiteBoard");
 
  m_algResourcePool = serviceLocator()->service("AlgResourcePool");
  if( !m_algResourcePool.isValid() ) {
    ATH_MSG_FATAL("Error retrieving AlgResourcePool");
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("initialised AlgResourcePool");
 
  m_aess = serviceLocator()->service("AlgExecStateSvc");
  if( !m_aess.isValid() ) {
    ATH_MSG_FATAL("Error retrieving AlgExecStateSvc");
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("initialised AlgExecStateSvc");
 
  //----------------------------------------------------------------------------
  // Initialise services
  //----------------------------------------------------------------------------
  ATH_CHECK(m_incidentSvc.retrieve());
  ATH_CHECK(m_evtStore.retrieve());
  ATH_CHECK(m_detectorStore.retrieve());
  ATH_CHECK(m_inputMetaDataStore.retrieve());
  ATH_CHECK(m_evtSelector.retrieve());
  ATH_CHECK(m_evtSelector->createContext(m_evtSelContext)); // create an EvtSelectorContext
  ATH_CHECK(m_outputCnvSvc.retrieve());
  ATH_CHECK(m_ioCompMgr.retrieve());
  if (m_monitorScheduler) {
    ATH_CHECK(m_schedulerMonSvc.retrieve());
  }
 
  //----------------------------------------------------------------------------
  // Initialise tools
  //----------------------------------------------------------------------------
  // COOL helper
  ATH_CHECK(m_coolHelper.retrieve());
  // HLT result builder
  ATH_CHECK(m_hltResultMaker.retrieve());
  // Monitoring tools
  if (!m_monTool.empty()) ATH_CHECK(m_monTool.retrieve());
  ATH_CHECK(m_errorMonTool.retrieve());
 
  //----------------------------------------------------------------------------
  // Initialise data handle keys
  //----------------------------------------------------------------------------
  // EventContext WriteHandle
  ATH_CHECK(m_eventContextWHKey.initialize());
  // EventInfo ReadHandle
  ATH_CHECK(m_eventInfoRHKey.initialize());
  // HLTResultMT ReadHandle (created dynamically from the result builder property)
  m_hltResultRHKey = m_hltResultMaker->resultName();
  ATH_CHECK(m_hltResultRHKey.initialize());
  // L1TriggerResult and RoIBResult ReadHandles for RewriteLVL1
  ATH_CHECK(m_l1TriggerResultRHKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_roibResultRHKey.initialize(SG::AllowEmpty));
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

inputThreadCallback()

void HltEventLoopMgr::inputThreadCallback ( )

private

Definition at line 1057 of file HltEventLoopMgr.cxx.

                                          {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  if (m_loopStatus.loopEnded) {
    ATH_MSG_VERBOSE("Event loop ended, stopping the input thread and returning from " << __FUNCTION__);
    m_inputThread->stop();
    // Notify output thread which may be still waiting for events
    m_outputThread->cond().notify_all();
    return;
  }
 
  // Early exit conditions
  if (!m_loopStatus.eventsAvailable) {
    ATH_MSG_VERBOSE("No more events, flagging the event loop as finished, stopping the input thread"
                    << " and returning from " << __FUNCTION__);
    m_inputThread->stop();
    // Notify output thread which may be still waiting for events
    m_outputThread->cond().notify_all();
    return;
  }
  const size_t numSlotsToFill = m_freeSlots.load();
  if (numSlotsToFill==0) {
    ATH_MSG_VERBOSE("No free slots, returning from " << __FUNCTION__);
    return;
  }
  m_freeSlots -= numSlotsToFill;
 
  // Read in and start processing another event
  ATH_MSG_DEBUG("Free slots = " << numSlotsToFill << ". Reading new event(s) to fill the slot(s).");
 
  // Fill all free slots with new events
  for (size_t i=0; i<numSlotsToFill; ++i) {
    auto task = [mgr=this](){
      StatusCode sc = StatusCode::SUCCESS;
      try {
        sc = mgr->startNextEvent();
      }
      catch (const std::exception& e) {
        mgr->error() << "Exception caught in startNextEvent: " << e.what() << endmsg;
        sc = StatusCode::FAILURE;
      }
      catch (...) {
        mgr->error() << "Exception caught in startNextEvent" << endmsg;
        sc = StatusCode::FAILURE;
      }
      if (sc.isFailure()) {
        mgr->error() << "startNextEvent failed, stopping the event loop" << endmsg;
        mgr->m_loopStatus.exitCode = StatusCode::FAILURE;
        mgr->m_loopStatus.eventsAvailable = false;
        return;
      }
      // Pop one item from parallel I/O queue to decrement its size - it doesn't matter which item
      // is popped, we only use the queue size to limit the number of tasks running in parallel
      bool popIOQueue{false};
      mgr->m_parallelIOQueue.pop(popIOQueue);
    };
 
    // Push one item to the parallel I/O queue to increment its size - the value doesn't matter,
    // we only use the queue size and benefit from the blocking push call here to limit the number
    // of tasks running in parallel. Once we can push to the queue, we can schedule the task.
    m_parallelIOQueue.push(true);
    m_parallelIOTaskGroup.run(std::move(task));
  }
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
}

nextEvent()

StatusCode HltEventLoopMgr::nextEvent ( int  maxevt = -1 )

overridevirtual

Implementation of IEventProcessor::nextEvent which implements the event loop.

Parameters

maxevt

number of events to process, -1 means all

Definition at line 524 of file HltEventLoopMgr.cxx.

{
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  // Start the event timer thread
  ATH_MSG_DEBUG("Starting the timeout thread");
  m_timeoutThread = std::make_unique<HLT::LoopThread>([this]{return eventTimerCallback();}, m_timeoutThreadIntervalMs.value());
  m_timeoutThread->start();
 
  // Start the event loop
  ATH_MSG_INFO("Starting loop on events");
  std::unique_lock<std::mutex> lock{m_loopStatus.loopEndedMutex};
  m_inputThread = std::make_unique<HLT::LoopThread>([this]{return inputThreadCallback();}, m_maxIOWakeUpIntervalMs.value());
  m_outputThread = std::make_unique<HLT::LoopThread>([this]{return outputThreadCallback();}, m_maxIOWakeUpIntervalMs.value());
  m_outputThread->start();
  m_inputThread->start();
 
  // Wait for event loop to end. The condition means the main input and output threads flagged they have
  // nothing else to do and will exit asynchronously (later than the wait here ends)
  ATH_MSG_DEBUG("Event loop started, the main thread is going to sleep until it finishes");
  m_loopStatus.loopEndedCond.wait(lock, [this](){return m_loopStatus.loopEnded.load();});
  ATH_MSG_INFO("All events processed, finalising the event loop");
 
  // Wait for the I/O TBB tasks and main I/O threads to finish. Note the TBB tasks need to finish first
  // because they may notify the condition variables in the main I/O threads. The lifetime of the condition
  // variables must span beyond any I/O TBB task.
  ATH_MSG_DEBUG("Waiting for all I/O tasks and threads to return");
  m_parallelIOTaskGroup.wait();
  m_inputThread.reset();
  m_outputThread.reset();
 
  // Stop the event timer thread
  ATH_MSG_DEBUG("All I/O threads and tasks finished. Stopping the timeout thread");
  m_timeoutThread->stop();
  m_timeoutThread.reset();
  ATH_MSG_DEBUG("The timeout thread finished");
 
  ATH_MSG_INFO("Finished loop on events");
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

operator=() [1/2]

HltEventLoopMgr& HltEventLoopMgr::operator= ( const HltEventLoopMgr &  )

delete

operator=() [2/2]

HltEventLoopMgr& HltEventLoopMgr::operator= ( HltEventLoopMgr &&  )

delete

outputThreadCallback()

void HltEventLoopMgr::outputThreadCallback ( )

private

The method executed by the output handling thread.

Definition at line 1123 of file HltEventLoopMgr.cxx.

                                           {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  const size_t nslots = m_isSlotProcessing.size(); // size is fixed in hltUpdateAfterFork after configuring scheduler
  if (m_schedulerSvc->freeSlots() == nslots) {
    if (m_loopStatus.eventsAvailable) {
      ATH_MSG_DEBUG("There are currently no events being processed by the Scheduler, returning from " << __FUNCTION__);
    } else {
      ATH_MSG_DEBUG("No more events to process and scheduler is empty, stopping the event loop and output thread");
      if (!m_loopStatus.loopEnded && m_outputThread!=nullptr) {
        m_outputThread->stop();
      }
      // Notify input thread which may be still waiting for free slots
      if (!m_loopStatus.loopEnded && m_inputThread!=nullptr) {
        m_inputThread->cond().notify_all();
      }
      // Notify the main thread that the loop ended - this is the only place able to do this!
      m_loopStatus.loopEnded = true;
      m_loopStatus.loopEndedCond.notify_all();
    }
    return;
  }
 
  //----------------------------------------------------------------------------
  // Pop events from the Scheduler
  //----------------------------------------------------------------------------
  std::vector<EventContext*> finishedEvtContexts;
  EventContext* finishedEvtContext(nullptr);
  const auto popStartTime = std::chrono::steady_clock::now();
 
  // Pop one event from the scheduler (blocking call)
  ATH_MSG_DEBUG("Waiting for a finished event from the Scheduler");
  if (m_schedulerSvc->popFinishedEvent(finishedEvtContext).isFailure()) {
    failedEvent(HLT::OnlineErrorCode::SCHEDULER_POP_FAILURE, EventContext()).ignore();
    delete finishedEvtContext;
    return;
  }
  ATH_MSG_DEBUG("Scheduler returned a finished event: " << finishedEvtContext);
  finishedEvtContexts.push_back(finishedEvtContext);
 
  // See if more events are available (non-blocking call)
  while (m_schedulerSvc->tryPopFinishedEvent(finishedEvtContext).isSuccess()){
    ATH_MSG_DEBUG("Scheduler returned a finished event: " << *finishedEvtContext);
    finishedEvtContexts.push_back(finishedEvtContext);
  }
  const auto popSpentTime = std::chrono::steady_clock::now() - popStartTime;
  const auto popSpentTimeMs = std::chrono::duration_cast<std::chrono::milliseconds>(popSpentTime).count();
  Monitored::Scalar<int64_t> monPopSchedulerTime{"PopSchedulerTime", popSpentTimeMs};
  Monitored::Scalar<size_t> monPopSchedulerNumEvt{"PopSchedulerNumEvt", finishedEvtContexts.size()};
  Monitored::Group{m_monTool, monPopSchedulerNumEvt, monPopSchedulerTime};
 
  //----------------------------------------------------------------------------
  // Post-process the finished events
  //----------------------------------------------------------------------------
  const size_t nFinishedEvents = finishedEvtContexts.size();
  ATH_MSG_DEBUG("Number of finished events to post-process: " << nFinishedEvents);
 
  // Push all post-processing tasks to TBB
  for (EventContext* thisFinishedEvtContext : finishedEvtContexts) {
    // Reset free slot timer for monitoring
    if (thisFinishedEvtContext != nullptr) {
      m_freeSlotStartPoint[thisFinishedEvtContext->slot()] = std::chrono::steady_clock::now();
    }
 
    // Create and enqueue the task
    m_finishedEventsQueue.push(thisFinishedEvtContext);
    auto task = [mgr=this](){
      StatusCode sc = StatusCode::SUCCESS;
      try {
        sc = mgr->processFinishedEvent();
      }
      catch (const std::exception& e) {
        mgr->error() << "Exception caught in processFinishedEvent: " << e.what() << endmsg;
        sc = StatusCode::FAILURE;
      }
      catch (...) {
        mgr->error() << "Exception caught in processFinishedEvent" << endmsg;
        sc = StatusCode::FAILURE;
      }
 
      if (sc.isFailure()) {
        mgr->error() << "processFinishedEvent failed, stopping the event loop" << endmsg;
        mgr->m_loopStatus.exitCode = StatusCode::FAILURE;
        mgr->m_loopStatus.eventsAvailable = false;
      }
 
      // Pop one item from parallel I/O queue to decrement its size - it doesn't matter which item
      // is popped, we only use the queue size to limit the number of tasks running in parallel
      bool popIOQueue{false};
      mgr->m_parallelIOQueue.pop(popIOQueue);
 
      // Wake up the output thread if it's sleeping - this prevents a deadlock after the last event
      // when input thread already finished and is no longer waking up the output thread. Spurious wake-ups
      // during the event loop from this notification should have negligible effect on CPU load.
      mgr->m_outputThread->cond().notify_one();
    };
 
    // Push one item to the parallel I/O queue to increment its size - the value doesn't matter,
    // we only use the queue size and benefit from the blocking push call here to limit the number
    // of tasks running in parallel. Once we can push to the queue, we can schedule the task.
    m_parallelIOQueue.push(true);
    m_parallelIOTaskGroup.run(std::move(task));
  }
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
}

prepareForStart()

StatusCode HltEventLoopMgr::prepareForStart ( const boost::property_tree::ptree &  pt )

overridevirtual

Definition at line 280 of file HltEventLoopMgr.cxx.

{
  try {
    const auto& rparams = pt.get_child("RunParams");
    m_sorHelper = std::make_unique<TrigSORFromPtreeHelper>(msgSvc(), m_detectorStore, m_sorPath, rparams);
  }
  catch(ptree_bad_path& e) {
    ATH_MSG_ERROR("Bad ptree path: \"" << e.path<ptree::path_type>().dump() << "\" - " << e.what());
    return StatusCode::FAILURE;
  }
 
  // Override run/timestamp if needed
  if (m_forceRunNumber > 0) {
    m_sorHelper->setRunNumber(m_forceRunNumber);
    ATH_MSG_WARNING("Run number overwrite:" << m_forceRunNumber);
  }
  if (m_forceSOR_ns > 0) {
    m_sorHelper->setSORtime_ns(m_forceSOR_ns);
    ATH_MSG_WARNING("SOR time overwrite:" << m_forceSOR_ns);
  }
 
  // Set our "run context"
  m_currentRunCtx.setEventID( m_sorHelper->eventID() );
  m_currentRunCtx.setExtension(Atlas::ExtendedEventContext(m_evtStore->hiveProxyDict(),
                                                           m_currentRunCtx.eventID().run_number()));
 
  // Some algorithms expect a valid context during start()
  ATH_MSG_DEBUG("Setting context for start transition: " << m_currentRunCtx.eventID());
  Gaudi::Hive::setCurrentContext(m_currentRunCtx);
 
  try {
    ATH_CHECK( clearTemporaryStores() );                 // do the necessary resets
    ATH_CHECK( m_sorHelper->fillSOR(m_currentRunCtx) );  // update SOR in det store
 
    const auto& soral = getSorAttrList();
    updateMetadataStore(soral);  // update metadata store
  }
  catch(const std::exception& e) {
    ATH_MSG_ERROR("Exception: " << e.what());
  }
 
  ATH_CHECK( updateMagField(pt) );  // update magnetic field
 
  return StatusCode::SUCCESS;
}

printSORAttrList()

void HltEventLoopMgr::printSORAttrList ( const coral::AttributeList &  atr ) const

private

Print the SOR record.

Definition at line 741 of file HltEventLoopMgr.cxx.

{
  unsigned long long sorTime_ns(atr["SORTime"].data<unsigned long long>());
 
  // Human readable format of SOR time
  time_t sorTime_sec = sorTime_ns / std::nano::den;
  struct tm buf;
 
  ATH_MSG_INFO("SOR parameters:");
  ATH_MSG_INFO("   RunNumber             = " << atr["RunNumber"].data<unsigned int>());
  ATH_MSG_INFO("   SORTime [ns]          = " << sorTime_ns <<
               " (" << std::put_time(localtime_r(&sorTime_sec, &buf), "%F %T") << ") ");
 
  auto dmfst = atr["DetectorMaskFst"].data<unsigned long long>();
  auto dmsnd = atr["DetectorMaskSnd"].data<unsigned long long>();
  ATH_MSG_INFO("   DetectorMaskFst       = 0x" << std::format("{:016x}", dmfst));
  ATH_MSG_INFO("   DetectorMaskSnd       = 0x" << std::format("{:016x}", dmsnd));
  ATH_MSG_INFO("   Complete DetectorMask = 0x" << std::format("{:016x}", dmfst)
                                               << std::format("{:016x}", dmsnd));
 
  ATH_MSG_INFO("   RunType               = " << atr["RunType"].data<std::string>());
  ATH_MSG_INFO("   RecordingEnabled      = " << (atr["RecordingEnabled"].data<bool>() ? "true" : "false"));
}

processFinishedEvent()

StatusCode HltEventLoopMgr::processFinishedEvent ( )

private

Perform all end-of-event actions for a single event popped out from the scheduler.

Definition at line 1450 of file HltEventLoopMgr.cxx.

{
  EventContext* eventContext{nullptr};
  m_finishedEventsQueue.pop(eventContext);
 
  StatusCode sc = StatusCode::SUCCESS;
  auto check = [this, &sc, &eventContext](std::string&& errmsg, HLT::OnlineErrorCode errcode) {
    if (sc.isSuccess()) {return false;}
    ATH_MSG_ERROR(errmsg);
    const EventContext& eventContextRef = (eventContext==nullptr) ? EventContext() : *eventContext;
    sc = failedEvent(errcode, eventContextRef);
    Gaudi::Hive::setCurrentContext(EventContext());
    delete eventContext;
    return true;
  };
 
  //--------------------------------------------------------------------------
  // Basic checks, select slot, retrieve event info
  //--------------------------------------------------------------------------
  // Check if the EventContext object exists
  if (eventContext == nullptr) {
    sc = StatusCode::FAILURE;
    if (check("Detected nullptr EventContext while finalising a processed event",
              HLT::OnlineErrorCode::CANNOT_ACCESS_SLOT)) {
      return sc;
    }
  }
 
  // Set ThreadLocalContext to the currently processed finished context
  Gaudi::Hive::setCurrentContext(eventContext);
 
  // Check the event processing status
  if (m_aess->eventStatus(*eventContext) != EventStatus::Success) {
    sc = StatusCode::FAILURE;
    auto algErrors = m_errorMonTool->algExecErrors(*eventContext);
    const HLT::OnlineErrorCode errCode = isTimedOut(algErrors) ?
                                         HLT::OnlineErrorCode::TIMEOUT : HLT::OnlineErrorCode::PROCESSING_FAILURE;
    if (check("Processing event with context " + toString(*eventContext) + \
              " failed with status " + toString(m_aess->eventStatus(*eventContext)),
              errCode)) {
      return sc;
    }
  }
 
  // Select the whiteboard slot
  sc = m_whiteboard->selectStore(eventContext->slot());
  if (check("Failed to select event store slot " + std::to_string(eventContext->slot()),
            HLT::OnlineErrorCode::CANNOT_ACCESS_SLOT)) {
    return sc;
  }
 
  // Fire EndProcessing incident - some services may depend on this
  m_incidentSvc->fireIncident(Incident(name(), IncidentType::EndProcessing, *eventContext));
 
  //--------------------------------------------------------------------------
  // HLT output handling
  //--------------------------------------------------------------------------
  // Call the result builder to record HLTResultMT in SG
  sc = m_hltResultMaker->makeResult(*eventContext);
  if (check("Failed to create the HLT result object", HLT::OnlineErrorCode::NO_HLT_RESULT)) {return sc;}
 
  // Connect output (create the output container) - the argument is currently not used
  sc = m_outputCnvSvc->connectOutput("");
  if (check("Conversion service failed to connectOutput", HLT::OnlineErrorCode::OUTPUT_BUILD_FAILURE)) {return sc;}
 
  // Retrieve the HLT result and the corresponding DataObject
  auto hltResult = SG::makeHandle(m_hltResultRHKey,*eventContext);
  if (!hltResult.isValid()) {sc = StatusCode::FAILURE;}
  if (check("Failed to retrieve the HLT result", HLT::OnlineErrorCode::NO_HLT_RESULT)) {return sc;}
 
  DataObject* hltResultDO = m_evtStore->accessData(hltResult.clid(),hltResult.key());
  if (hltResultDO == nullptr) {sc = StatusCode::FAILURE;}
  if (check("Failed to retrieve the HLTResult DataObject", HLT::OnlineErrorCode::NO_HLT_RESULT)) {return sc;}
 
  // Check for result truncation
  if (!hltResult->getTruncatedModuleIds().empty() && hltResult->severeTruncation()) {sc = StatusCode::FAILURE;}
  if (check("HLT result truncation", HLT::OnlineErrorCode::RESULT_TRUNCATION)) {return sc;}
 
  // Convert the HLT result to the output data format
  IOpaqueAddress* addr = nullptr;
  sc = m_outputCnvSvc->createRep(hltResultDO,addr);
  if (sc.isFailure()) {delete addr;}
  if (check("Conversion service failed to convert HLTResult", HLT::OnlineErrorCode::OUTPUT_BUILD_FAILURE)) {return sc;}
 
  // Retrieve and convert the L1 result to the output data format
  IOpaqueAddress* l1addr = nullptr;
  IOpaqueAddress* l1addrLegacy = nullptr;
  if (m_rewriteLVL1) {
    // Run-3 L1 simulation result
    if (not m_l1TriggerResultRHKey.empty()) {
      auto l1TriggerResult = SG::makeHandle(m_l1TriggerResultRHKey, *eventContext);
      if (!l1TriggerResult.isValid()) {sc = StatusCode::FAILURE;}
      if (check("Failed to retrieve the L1 Trigger Result for RewriteLVL1",
                HLT::OnlineErrorCode::OUTPUT_BUILD_FAILURE)) {
        return sc;
      }
 
      DataObject* l1TriggerResultDO = m_evtStore->accessData(l1TriggerResult.clid(),l1TriggerResult.key());
      if (l1TriggerResultDO == nullptr) {sc = StatusCode::FAILURE;}
      if (check("Failed to retrieve the L1 Trigger Result DataObject for RewriteLVL1",
                HLT::OnlineErrorCode::OUTPUT_BUILD_FAILURE)) {
        return sc;
      }
 
      sc = m_outputCnvSvc->createRep(l1TriggerResultDO,l1addr);
      if (sc.isFailure()) {delete l1addr;}
      if (check("Conversion service failed to convert L1 Trigger Result for RewriteLVL1",
                HLT::OnlineErrorCode::OUTPUT_BUILD_FAILURE)) {
        return sc;
      }
    }
    // Legacy (Run-2) L1 simulation result
    if (not m_roibResultRHKey.empty()) {
      auto roibResult = SG::makeHandle(m_roibResultRHKey, *eventContext);
      if (!roibResult.isValid()) {sc = StatusCode::FAILURE;}
      if (check("Failed to retrieve the RoIBResult for RewriteLVL1",
                HLT::OnlineErrorCode::OUTPUT_BUILD_FAILURE)) {
        return sc;
      }
 
      DataObject* roibResultDO = m_evtStore->accessData(roibResult.clid(),roibResult.key());
      if (roibResultDO == nullptr) {sc = StatusCode::FAILURE;}
      if (check("Failed to retrieve the RoIBResult DataObject for RewriteLVL1",
                HLT::OnlineErrorCode::OUTPUT_BUILD_FAILURE)) {
        return sc;
      }
 
      sc = m_outputCnvSvc->createRep(roibResultDO,l1addrLegacy);
      if (sc.isFailure()) {delete l1addrLegacy;}
      if (check("Conversion service failed to convert RoIBResult for RewriteLVL1",
                HLT::OnlineErrorCode::OUTPUT_BUILD_FAILURE)) {
        return sc;
      }
    }
  }
 
  // Save event processing time before sending output
  bool eventAccepted = !hltResult->getStreamTags().empty();
  auto eventTime = std::chrono::steady_clock::now() - m_eventTimerStartPoint[eventContext->slot()];
  int64_t eventTimeMillisec = std::chrono::duration_cast<std::chrono::milliseconds>(eventTime).count();
 
  // Commit output (write/send the output data) - the arguments are currently not used
  sc = m_outputCnvSvc->commitOutput("",true);
  if (sc.isFailure()) {delete addr;}
  if (check("Conversion service failed to commitOutput", HLT::OnlineErrorCode::OUTPUT_SEND_FAILURE)) {return sc;}
 
  // The output has been sent out, the ByteStreamAddress can be deleted
  delete addr;
  delete l1addr;
  delete l1addrLegacy;
 
  //------------------------------------------------------------------------
  // Reset the timeout flag and the timer, and mark the slot as idle
  //------------------------------------------------------------------------
  resetEventTimer(*eventContext, /*processing=*/ false);
 
  //--------------------------------------------------------------------------
  // Clear the slot
  //--------------------------------------------------------------------------
  ATH_MSG_DEBUG("Clearing slot " << eventContext->slot()
                << " (event " << eventContext->evt() << ") of the whiteboard");
 
  sc = clearWBSlot(eventContext->slot());
  if (check("Whiteboard slot " + std::to_string(eventContext->slot()) + " could not be properly cleared",
            HLT::OnlineErrorCode::AFTER_RESULT_SENT)) {
    return sc;
  }
 
  ATH_MSG_DEBUG("Finished processing " << (eventAccepted ? "accepted" : "rejected")
                << " event with context " << *eventContext
                << " which took " << eventTimeMillisec << " ms");
 
  // Only now after store clearing we can allow the slot to be filled again,
  // so we increment m_freeSlots and notify the input thread
  ++m_freeSlots;
  if (!m_loopStatus.loopEnded && m_inputThread!=nullptr) {
    m_inputThread->cond().notify_all();
  }
 
  // Fill the time monitoring histograms
  auto monTimeAny = Monitored::Scalar<int64_t>("TotalTime", eventTimeMillisec);
  auto monTimeAcc = Monitored::Scalar<int64_t>(eventAccepted ? "TotalTimeAccepted" : "TotalTimeRejected", eventTimeMillisec);
  Monitored::Group(m_monTool, monTimeAny, monTimeAcc);
 
  // Set ThreadLocalContext to an invalid context as we entering a context-less environment
  Gaudi::Hive::setCurrentContext( EventContext() );
 
  // Delete the EventContext which was created when calling executeEvent( EventContext(*eventContext) )
  delete eventContext;
 
  return StatusCode::SUCCESS;
}

resetEventTimer()

void HltEventLoopMgr::resetEventTimer ( const EventContext &  eventContext, bool  processing  )

private

Reset the timeout flag and the timer, and mark the slot as busy or idle according to the second argument.

Definition at line 1031 of file HltEventLoopMgr.cxx.

                                                                                       {
  if (!eventContext.valid()) {return;}
  {
    std::unique_lock<std::mutex> lock(m_timeoutThread->mutex());
    m_eventTimerStartPoint[eventContext.slot()] = std::chrono::steady_clock::now();
    m_isSlotProcessing[eventContext.slot()] = processing;
    resetTimeout(Athena::Timeout::instance(eventContext));
  }
  m_timeoutThread->cond().notify_all();
}

resetTimeout()

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

inlineprotectedinherited

Reset timeout.

Definition at line 83 of file Timeout.h.

{ instance.reset(); }

setTimeout()

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

inlineprotectedinherited

Set timeout.

Definition at line 80 of file Timeout.h.

{ instance.set(); }

startNextEvent()

StatusCode HltEventLoopMgr::startNextEvent ( )

private

Definition at line 1230 of file HltEventLoopMgr.cxx.

{
  StatusCode sc = StatusCode::SUCCESS;
  auto check = [this, &sc](std::string&& errmsg, HLT::OnlineErrorCode errcode, const EventContext& eventContext) {
    if (sc.isSuccess()) {return false;}
    ATH_MSG_ERROR(errmsg);
    sc = failedEvent(errcode, eventContext);
    Gaudi::Hive::setCurrentContext(EventContext());
    return true;
  };
 
  //------------------------------------------------------------------------
  // Allocate event slot and create new EventContext
  //------------------------------------------------------------------------
 
  // Create an EventContext, allocating and selecting a whiteboard slot
  std::unique_ptr<EventContext> eventContextPtr = std::make_unique<EventContext>(createEventContext());
 
  sc = eventContextPtr->valid() ? StatusCode(StatusCode::SUCCESS) : StatusCode(StatusCode::FAILURE);
  if (check("Failed to allocate slot for a new event", HLT::OnlineErrorCode::BEFORE_NEXT_EVENT, *eventContextPtr)) {
    return sc;
  }
 
  sc = m_whiteboard->selectStore(eventContextPtr->slot());
  if (check("Failed to select event store slot number " + std::to_string(eventContextPtr->slot()),
            HLT::OnlineErrorCode::BEFORE_NEXT_EVENT, *eventContextPtr)) {
    return sc;
  }
 
  // We can completely avoid using ThreadLocalContext if we store the EventContext in the event store. Any
  // service/tool method which does not allow to pass EventContext as argument, can const-retrieve it from the
  // event store rather than using ThreadLocalContext.
 
  // We link the current store in the extension of the EventContext we just created. Only then we create
  // a WriteHandle for the EventContext using the EventContext itself. The handle will use the linked hiveProxyDict
  // to record the context in the current store.
  eventContextPtr->setExtension(Atlas::ExtendedEventContext(m_evtStore->hiveProxyDict(),
                                                            m_currentRunCtx.eventID().run_number()));
  auto eventContext = SG::makeHandle(m_eventContextWHKey,*eventContextPtr);
  sc = eventContext.record(std::move(eventContextPtr));
  if (check("Failed to record new EventContext in the event store",
            HLT::OnlineErrorCode::BEFORE_NEXT_EVENT, *eventContext)) {
    return sc;
  }
 
  // Reset the AlgExecStateSvc
  m_aess->reset(*eventContext);
 
  ATH_MSG_DEBUG("Created new EventContext with number: " << eventContext->evt()
                << ", slot: " << eventContext->slot());
 
  // This ThreadLocalContext call is a not-so-nice behind-the-scenes way to inform some services about the current
  // context. If possible, services should use EventContext from the event store as recorded above. We have to set
  // the ThreadLocalContext here because some services still use it.
  Gaudi::Hive::setCurrentContext(*eventContext);
 
  //------------------------------------------------------------------------
  // Create a new address for EventInfo to facilitate automatic conversion from input data
  //------------------------------------------------------------------------
  IOpaqueAddress* addr = nullptr;
  sc = m_evtSelector->createAddress(*m_evtSelContext, addr);
  if (check("Event selector failed to create an IOpaqueAddress",
            HLT::OnlineErrorCode::BEFORE_NEXT_EVENT, *eventContext)) {
    return sc;
  }
 
  //------------------------------------------------------------------------
  // Get the next event
  //------------------------------------------------------------------------
  try {
    bool noEventsTemporarily{false};
    do {
      try {
        noEventsTemporarily = false;
        sc = m_evtSelector->next(*m_evtSelContext);
      } catch (const hltonl::Exception::NoEventsTemporarily& e) {
        ATH_MSG_DEBUG("No new input events available temporarily, requesting again");
        noEventsTemporarily = true;
      }
    } while (noEventsTemporarily);
  }
  catch (const hltonl::Exception::NoMoreEvents& e) {
    sc = StatusCode::SUCCESS;
    m_loopStatus.eventsAvailable = false;
    sc = clearWBSlot(eventContext->slot());
    if (sc.isFailure()) {
      ATH_MSG_WARNING("Failed to clear the whiteboard slot " << eventContext->slot()
                      << " after NoMoreEvents detected");
    }
    // Increment m_freeSlots after clearing the store and notify the input thread
    ++m_freeSlots;
    if (!m_loopStatus.loopEnded && m_inputThread!=nullptr) {
      m_inputThread->cond().notify_all();
    }
    return StatusCode::SUCCESS;
  }
  catch (const hltonl::Exception::MissingCTPFragment& e) {
    sc = StatusCode::FAILURE;
    if (check(e.what(), HLT::OnlineErrorCode::MISSING_CTP_FRAGMENT, *eventContext)) {
      return sc;
    }
  }
  catch (const hltonl::Exception::BadCTPFragment& e) {
    sc = StatusCode::FAILURE;
    if (check(e.what(), HLT::OnlineErrorCode::BAD_CTP_FRAGMENT, *eventContext)) {
      return sc;
    }
  }
  catch (const std::exception& e) {
    ATH_MSG_ERROR("Failed to get next event from the event source, std::exception caught: " << e.what());
    sc = StatusCode::FAILURE;
  }
  catch (...) {
    ATH_MSG_ERROR("Failed to get next event from the event source, unknown exception caught");
    sc = StatusCode::FAILURE;
  }
  if (check("Failed to get the next event",
            HLT::OnlineErrorCode::CANNOT_RETRIEVE_EVENT, *eventContext)) {
    return sc;
  }
 
  //------------------------------------------------------------------------
  // Reset the timeout flag and the timer, and mark the slot as busy
  //------------------------------------------------------------------------
  resetEventTimer(*eventContext, /*processing=*/ true);
 
  //------------------------------------------------------------------------
  // Load event proxies and get event info
  //------------------------------------------------------------------------
  sc = m_evtStore->loadEventProxies();
  if (check("Failed to load event proxies", HLT::OnlineErrorCode::NO_EVENT_INFO, *eventContext)) {
    return sc;
  }
 
  auto eventInfo = SG::makeHandle(m_eventInfoRHKey,*eventContext);
  sc = eventInfo.isValid() ? StatusCode::SUCCESS : StatusCode::FAILURE;
  if (check("Failed to retrieve EventInfo", HLT::OnlineErrorCode::NO_EVENT_INFO, *eventContext)) {
    return sc;
  }
 
  ATH_MSG_DEBUG("Retrieved event info for the new event " << *eventInfo);
 
  // Set EventID for the EventContext
  EventID eid = eventIDFromxAOD(eventInfo.cptr());
  // Override run/LB/timestamp if needed
  if (m_forceRunNumber > 0) {
    eid.set_run_number(m_forceRunNumber);
  }
  if (m_forceLumiblock > 0) {
    eid.set_lumi_block(m_forceLumiblock);
  }
  if (m_forceSOR_ns > 0) {
    eid.set_time_stamp(m_forceSOR_ns / std::nano::den);
    eid.set_time_stamp_ns_offset(m_forceSOR_ns % std::nano::den);
  }
  eventContext->setEventID(eid);
 
  // Update thread-local EventContext after setting EventID
  Gaudi::Hive::setCurrentContext(*eventContext);
 
  //-----------------------------------------------------------------------
  // COOL updates for LB changes
  //-----------------------------------------------------------------------
 
  // Check if this is a new LB
  EventIDBase::number_type oldMaxLB{0}, newMaxLB{0};
  bool updatedLB{false};
  do {
    oldMaxLB = m_loopStatus.maxLB.load();
    newMaxLB = std::max(oldMaxLB, eventContext->eventID().lumi_block());
    updatedLB = newMaxLB > oldMaxLB;
  } while (updatedLB && !m_loopStatus.maxLB.compare_exchange_strong(oldMaxLB, newMaxLB));
  m_loopStatus.maxLB.compare_exchange_strong(oldMaxLB, newMaxLB);
 
  // Wait in case a COOL update is ongoing to avoid executeEvent
  // reading conditions data while they are being updated.
  {
    std::unique_lock<std::mutex> lock(m_loopStatus.coolUpdateMutex);
    m_loopStatus.coolUpdateCond.wait(lock, [&]{return !m_loopStatus.coolUpdateOngoing;});
  }
 
  // Do COOL updates (if needed) and notify other threads about it
  if (updatedLB) {
    {
      std::lock_guard<std::mutex> lock(m_loopStatus.coolUpdateMutex);
      m_loopStatus.coolUpdateOngoing = true;
      sc = m_coolHelper->hltCoolUpdate(*eventContext);
      if (check("Failure during COOL update", HLT::OnlineErrorCode::COOL_UPDATE, *eventContext)) {
        m_loopStatus.coolUpdateOngoing = false;
        return sc;
      }
      m_loopStatus.coolUpdateOngoing = false;
    }
    m_loopStatus.coolUpdateCond.notify_all();
  }
 
  //------------------------------------------------------------------------
  // Process the event
  //------------------------------------------------------------------------
  // We need to make a copy of eventContext, as executeEvent uses move semantics and eventContext is already owned
  // by the event store. The copy we create here is pushed to the scheduler and retrieved back in drainScheduler
  // where we have to delete it.
  sc = executeEvent(EventContext(*eventContext));
  if (check("Failed to schedule event processing",
            HLT::OnlineErrorCode::SCHEDULING_FAILURE, *eventContext)) {
    return sc;
  }
  // Notify the output thread to start waiting for a finished event
  m_outputThread->cond().notify_one();
 
  //------------------------------------------------------------------------
  // Set ThreadLocalContext to an invalid context
  //------------------------------------------------------------------------
  // We have passed the event to the scheduler and we are entering back a context-less environment
  Gaudi::Hive::setCurrentContext( EventContext() );
 
  return sc;
}

stop()

StatusCode HltEventLoopMgr::stop ( )

overridevirtual

Definition at line 229 of file HltEventLoopMgr.cxx.

{
  // Need to reinitialize IO in the mother process
  if (m_workerID==0) {
    ATH_CHECK(m_ioCompMgr->io_reinitialize());
  }
 
  return StatusCode::SUCCESS;
}

stopRun()

StatusCode HltEventLoopMgr::stopRun ( )

overridevirtual

Implementation of IEventProcessor::stopRun (obsolete for online runnning)

Definition at line 570 of file HltEventLoopMgr.cxx.

                                    {
  ATH_MSG_FATAL("Misconfiguration - the method HltEventLoopMgr::stopRun() cannot be used online");
  return StatusCode::FAILURE;
}

updateDFProps()

void HltEventLoopMgr::updateDFProps ( )

private

Read DataFlow configuration properties.

Definition at line 618 of file HltEventLoopMgr.cxx.

{
  auto getDFProp = [&](const std::string& name, std::string& value, bool required = true) {
                     if (m_jobOptionsSvc->has("DataFlowConfig."+name)) {
                       value = m_jobOptionsSvc->get("DataFlowConfig."+name);
                       ATH_MSG_INFO(" ---> Read from DataFlow configuration: " << name << " = " << value);
                     } else {
                       msg() << (required ? MSG::WARNING : MSG::INFO)
                             << "Could not set Property " << name << " from DataFlow" << endmsg;
                     }
                   };
 
  getDFProp( "DF_ApplicationName", m_applicationName );
  std::string wid, wpid;
  getDFProp( "DF_WorkerId", wid, false );
  getDFProp( "DF_Pid", wpid, false );
  if (!wid.empty()) m_workerID = std::stoi(wid);
  if (!wpid.empty()) m_workerPID = std::stoi(wpid);
}

updateMagField()

StatusCode HltEventLoopMgr::updateMagField ( const boost::property_tree::ptree &  pt ) const

private

Set magnetic field currents from ptree.

Definition at line 668 of file HltEventLoopMgr.cxx.

{
  if (m_setMagFieldFromPtree) {
    try {
      auto tor_cur = pt.get<float>("Magnets.ToroidsCurrent.value");
      auto sol_cur = pt.get<float>("Magnets.SolenoidCurrent.value");
 
      // Set current on conditions alg
      const IAlgManager* algMgr = Gaudi::svcLocator()->as<IAlgManager>();
      IAlgorithm* fieldAlg{nullptr};
      algMgr->getAlgorithm("AtlasFieldMapCondAlg", fieldAlg).ignore();
      if ( fieldAlg != nullptr ) {
        ATH_MSG_INFO("Setting field currents on AtlasFieldMapCondAlg");
        ATH_CHECK( Gaudi::Utils::setProperty(fieldAlg, "MapSoleCurrent", sol_cur) );
        ATH_CHECK( Gaudi::Utils::setProperty(fieldAlg, "MapToroCurrent", tor_cur) );
      }
      else ATH_MSG_WARNING("Cannot retrieve AtlasFieldMapCondAlg");
 
      ATH_MSG_INFO("*****************************************");
      ATH_MSG_INFO("  Auto-configuration of magnetic field:  ");
      ATH_MSG_INFO("    solenoid current from IS = " << sol_cur);
      ATH_MSG_INFO("     torroid current from IS = " << tor_cur);
      ATH_MSG_INFO("*****************************************");
    }
    catch(ptree_bad_path& e) {
      ATH_MSG_ERROR( "Cannot read magnet currents from ptree: " << e.what() );
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

updateMetadataStore()

void HltEventLoopMgr::updateMetadataStore ( const coral::AttributeList &  sor_attrlist ) const

private

Definition at line 639 of file HltEventLoopMgr.cxx.

{
  auto metadatacont = std::make_unique<ByteStreamMetadataContainer>();
  metadatacont->push_back(std::make_unique<ByteStreamMetadata>(
    sor_attrlist["RunNumber"].data<unsigned int>(),
    0,
    0,
    sor_attrlist["RecordingEnabled"].data<bool>(),
    0,
    sor_attrlist["DetectorMaskSnd"].data<unsigned long long>(),
    sor_attrlist["DetectorMaskFst"].data<unsigned long long>(),
    0,
    0,
    "",
    "",
    "",
    0,
    std::vector<std::string>()
  ));
  // Record ByteStreamMetadataContainer in MetaData Store
  if(m_inputMetaDataStore->record(std::move(metadatacont),"ByteStreamMetadata").isFailure()) {
    ATH_MSG_WARNING("Unable to record MetaData in InputMetaDataStore");
  }
  else {
    ATH_MSG_DEBUG("Recorded MetaData in InputMetaDataStore");
  }
}

Member Data Documentation

m_aess

SmartIF<IAlgExecStateSvc> HltEventLoopMgr::m_aess

private

Definition at line 227 of file HltEventLoopMgr.h.

m_algErrorDebugStreamName

Gaudi::Property<std::string> HltEventLoopMgr::m_algErrorDebugStreamName

private

Initial value:

{
    this, "AlgErrorDebugStreamName", "HltError",
    "Debug stream name for events with HLT algorithm errors"}

Definition at line 271 of file HltEventLoopMgr.h.

m_algResourcePool

SmartIF<IAlgResourcePool> HltEventLoopMgr::m_algResourcePool

private

Definition at line 226 of file HltEventLoopMgr.h.

m_applicationName

std::string HltEventLoopMgr::m_applicationName

private

Application name.

Definition at line 359 of file HltEventLoopMgr.h.

m_coolHelper

ToolHandle<TrigCOOLUpdateHelper> HltEventLoopMgr::m_coolHelper {this, "CoolUpdateTool", "TrigCOOLUpdateHelper"}

private

Definition at line 220 of file HltEventLoopMgr.h.

m_currentRunCtx

EventContext HltEventLoopMgr::m_currentRunCtx {0,0}

private

"Event" context of current run with dummy event/slot number

Definition at line 325 of file HltEventLoopMgr.h.

m_detectorStore

ServiceHandle<StoreGateSvc> HltEventLoopMgr::m_detectorStore {this, "DetectorStore", "DetectorStore"}

private

Definition at line 214 of file HltEventLoopMgr.h.

m_errorMonTool

ToolHandle<ITrigErrorMonTool> HltEventLoopMgr::m_errorMonTool {this, "TrigErrorMonTool", "TrigErrorMonTool", "Error monitoring tool"}

private

Definition at line 223 of file HltEventLoopMgr.h.

m_eventContextWHKey

SG::WriteHandleKey<EventContext> HltEventLoopMgr::m_eventContextWHKey

private

Initial value:

{
    this, "EventContextWHKey", "EventContext", "StoreGate key for recording EventContext"}

Definition at line 308 of file HltEventLoopMgr.h.

m_eventInfoRHKey

SG::ReadHandleKey<xAOD::EventInfo> HltEventLoopMgr::m_eventInfoRHKey

private

Initial value:

{
    this, "EventInfoRHKey", "EventInfo", "StoreGate key for reading xAOD::EventInfo"}

Definition at line 311 of file HltEventLoopMgr.h.

m_eventTimerStartPoint

std::vector<std::chrono::steady_clock::time_point> HltEventLoopMgr::m_eventTimerStartPoint

private

Vector of event start-processing time stamps in each slot.

Definition at line 331 of file HltEventLoopMgr.h.

m_evtSelContext

IEvtSelector::Context* HltEventLoopMgr::m_evtSelContext {nullptr}

private

Event selector context.

Definition at line 329 of file HltEventLoopMgr.h.

m_evtSelector

ServiceHandle<IEvtSelector> HltEventLoopMgr::m_evtSelector {this, "EvtSel", "EvtSel"}

private

Definition at line 217 of file HltEventLoopMgr.h.

m_evtStore

ServiceHandle<StoreGateSvc> HltEventLoopMgr::m_evtStore {this, "EventStore", "StoreGateSvc"}

private

Definition at line 213 of file HltEventLoopMgr.h.

m_execAtStart

Gaudi::Property<std::vector<std::string> > HltEventLoopMgr::m_execAtStart

private

Initial value:

{
    this, "execAtStart", {}, "List of algorithms/sequences to execute during prepareForRun"}

Definition at line 286 of file HltEventLoopMgr.h.

m_finishedEventsQueue

tbb::concurrent_bounded_queue<EventContext*> HltEventLoopMgr::m_finishedEventsQueue

private

Queue of events ready for output processing.

Definition at line 351 of file HltEventLoopMgr.h.

m_forceLumiblock

Gaudi::Property<unsigned int> HltEventLoopMgr::m_forceLumiblock

private

Initial value:

{
    this, "forceLumiblock", 0, "Override lumiblock number"}

Definition at line 295 of file HltEventLoopMgr.h.

m_forceRunNumber

Gaudi::Property<unsigned int> HltEventLoopMgr::m_forceRunNumber

private

Initial value:

{
    this, "forceRunNumber", 0, "Override run number"}

Definition at line 292 of file HltEventLoopMgr.h.

m_forceSOR_ns

Gaudi::Property<unsigned long long> HltEventLoopMgr::m_forceSOR_ns

private

Initial value:

{
    this, "forceStartOfRunTime", 0, "Override SOR time (epoch in nano-seconds)"}

Definition at line 298 of file HltEventLoopMgr.h.

m_freeSlots

std::atomic<size_t> HltEventLoopMgr::m_freeSlots {0}

private

Number of free slots used to synchronise input/output tasks.

Definition at line 337 of file HltEventLoopMgr.h.

m_freeSlotStartPoint

std::vector<std::chrono::steady_clock::time_point> HltEventLoopMgr::m_freeSlotStartPoint

private

Vector of time stamps telling when each scheduler slot was freed.

Definition at line 333 of file HltEventLoopMgr.h.

m_fwkErrorDebugStreamName

Gaudi::Property<std::string> HltEventLoopMgr::m_fwkErrorDebugStreamName

private

Initial value:

{
    this, "FwkErrorDebugStreamName", "HLTMissingData",
    "Debug stream name for events with HLT framework errors"}

Definition at line 267 of file HltEventLoopMgr.h.

m_hardTimeout

Gaudi::Property<float> HltEventLoopMgr::m_hardTimeout

private

Initial value:

{
    this, "HardTimeout", 10*60*1000, "Hard event processing timeout in milliseconds"}

Definition at line 239 of file HltEventLoopMgr.h.

m_hltResultMaker

ToolHandle<HLTResultMTMaker> HltEventLoopMgr::m_hltResultMaker {this, "ResultMaker", "HLTResultMTMaker"}

private

Definition at line 221 of file HltEventLoopMgr.h.

m_hltResultRHKey

SG::ReadHandleKey<HLT::HLTResultMT> HltEventLoopMgr::m_hltResultRHKey

private

StoreGate key for reading the HLT result.

Definition at line 320 of file HltEventLoopMgr.h.

m_incidentSvc

ServiceHandle<IIncidentSvc> HltEventLoopMgr::m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}

private

Definition at line 211 of file HltEventLoopMgr.h.

m_inputMetaDataStore

ServiceHandle<StoreGateSvc> HltEventLoopMgr::m_inputMetaDataStore {this, "InputMetaDataStore", "StoreGateSvc/InputMetaDataStore"}

private

Definition at line 215 of file HltEventLoopMgr.h.

m_inputThread

std::unique_ptr<HLT::LoopThread> HltEventLoopMgr::m_inputThread

private

Input handling thread (triggers reading new events)

Definition at line 339 of file HltEventLoopMgr.h.

m_ioCompMgr

ServiceHandle<IIoComponentMgr> HltEventLoopMgr::m_ioCompMgr {this, "IoComponentMgr", "IoComponentMgr"}

private

Definition at line 216 of file HltEventLoopMgr.h.

m_isSlotProcessing

std::vector<bool> HltEventLoopMgr::m_isSlotProcessing

private

Vector of flags to tell if a slot is idle or processing.

Definition at line 335 of file HltEventLoopMgr.h.

m_jobOptionsSvc

ServiceHandle<Gaudi::Interfaces::IOptionsSvc> HltEventLoopMgr::m_jobOptionsSvc {this, "JobOptionsSvc", "JobOptionsSvc"}

private

Definition at line 212 of file HltEventLoopMgr.h.

m_l1TriggerResultRHKey

SG::ReadHandleKey<xAOD::TrigCompositeContainer> HltEventLoopMgr::m_l1TriggerResultRHKey

private

Initial value:

{
    this, "L1TriggerResultRHKey", "", "StoreGate key for reading L1TriggerResult for RewriteLVL1"}

Definition at line 314 of file HltEventLoopMgr.h.

m_localEventNumber

std::atomic<size_t> HltEventLoopMgr::m_localEventNumber {0}

private

Event counter used for local bookkeeping; incremental per instance of HltEventLoopMgr, unrelated to global_id.

Definition at line 327 of file HltEventLoopMgr.h.

m_loopStatus

EventLoopStatus HltEventLoopMgr::m_loopStatus {}

private

Object keeping track of the event loop status.

Definition at line 353 of file HltEventLoopMgr.h.

m_maxFrameworkErrors

Gaudi::Property<int> HltEventLoopMgr::m_maxFrameworkErrors

private

Initial value:

{
    this, "MaxFrameworkErrors", 10,
    "Tolerable number of recovered framework errors before exiting (<0 means all are tolerated)"}

Definition at line 263 of file HltEventLoopMgr.h.

m_maxIOWakeUpIntervalMs

Gaudi::Property<int> HltEventLoopMgr::m_maxIOWakeUpIntervalMs

private

Initial value:

{
    this, "MaxIOWakeUpIntervalMs", -1,
    "Maximum time input or output handling thread will sleep unless notified. Negative value (default) means no limit, "
    "i.e. threads will only wake up on notifications. Zero means threads will never wait for notifications. "
    "Positive value means the number of milliseconds after which a thread will wake up if it's not notified earlier."}

Definition at line 257 of file HltEventLoopMgr.h.

m_maxParallelIOTasks

Gaudi::Property<int> HltEventLoopMgr::m_maxParallelIOTasks

private

Initial value:

{
    this, "MaxParallelIOTasks", -1,
    "Maximum number of I/O tasks which can be executed in parallel. "
    "If <=0 then the number of scheduler threads is used."}

Definition at line 252 of file HltEventLoopMgr.h.

m_monitorScheduler

Gaudi::Property<bool> HltEventLoopMgr::m_monitorScheduler

private

Initial value:

{
    this, "MonitorScheduler", false, "Enable SchedulerMonSvc to collect scheduler status data in online histograms"}

Definition at line 305 of file HltEventLoopMgr.h.

m_monTool

ToolHandle<GenericMonitoringTool> HltEventLoopMgr::m_monTool {this, "MonTool", "", "Monitoring tool"}

private

Definition at line 222 of file HltEventLoopMgr.h.

m_nFrameworkErrors

std::atomic<int> HltEventLoopMgr::m_nFrameworkErrors {0}

private

Counter of framework errors.

Definition at line 357 of file HltEventLoopMgr.h.

m_outputCnvSvc

ServiceHandle<IConversionSvc> HltEventLoopMgr::m_outputCnvSvc {this, "OutputCnvSvc", "OutputCnvSvc"}

private

Definition at line 218 of file HltEventLoopMgr.h.

m_outputThread

std::unique_ptr<HLT::LoopThread> HltEventLoopMgr::m_outputThread

private

Output handling thread (triggers post-processing of finished events)

Definition at line 341 of file HltEventLoopMgr.h.

m_parallelIOQueue

tbb::concurrent_bounded_queue<bool> HltEventLoopMgr::m_parallelIOQueue

private

Queue limiting the number of parallel I/O tasks.

Definition at line 349 of file HltEventLoopMgr.h.

m_parallelIOTaskGroup

tbb::task_group HltEventLoopMgr::m_parallelIOTaskGroup

private

Task group to execute parallel I/O tasks asynchronously.

Definition at line 347 of file HltEventLoopMgr.h.

m_rewriteLVL1

Gaudi::Property<bool> HltEventLoopMgr::m_rewriteLVL1

private

Initial value:

{
    this, "RewriteLVL1", false,
    "Encode L1 results to ByteStream and write to the output. Possible only with athenaHLT, not online."}

Definition at line 301 of file HltEventLoopMgr.h.

m_roibResultRHKey

SG::ReadHandleKey<ROIB::RoIBResult> HltEventLoopMgr::m_roibResultRHKey

private

Initial value:

{
    this, "RoIBResultRHKey", "", "StoreGate key for reading RoIBResult for RewriteLVL1 with legacy (Run-2) L1 simulation"}

Definition at line 317 of file HltEventLoopMgr.h.

m_schedulerMonSvc

ServiceHandle<ISchedulerMonSvc> HltEventLoopMgr::m_schedulerMonSvc {this, "SchedulerMonSvc", "SchedulerMonSvc"}

private

Definition at line 219 of file HltEventLoopMgr.h.

m_schedulerName

Gaudi::Property<std::string> HltEventLoopMgr::m_schedulerName

private

Initial value:

{
    this, "SchedulerSvc", "AvalancheSchedulerSvc", "Name of the scheduler"}

Definition at line 233 of file HltEventLoopMgr.h.

m_schedulerSvc

SmartIF<IScheduler> HltEventLoopMgr::m_schedulerSvc

private

Definition at line 228 of file HltEventLoopMgr.h.

m_setMagFieldFromPtree

Gaudi::Property<bool> HltEventLoopMgr::m_setMagFieldFromPtree

private

Initial value:

{
    this, "setMagFieldFromPtree", true, "Read magnet currents from ptree"}

Definition at line 289 of file HltEventLoopMgr.h.

m_softTimeoutFraction

Gaudi::Property<float> HltEventLoopMgr::m_softTimeoutFraction

private

Initial value:

{
    this, "SoftTimeoutFraction", 0.8, "Fraction of the hard timeout to be set as the soft timeout"}

Definition at line 242 of file HltEventLoopMgr.h.

m_softTimeoutValue

std::chrono::milliseconds HltEventLoopMgr::m_softTimeoutValue {0}

private

Soft timeout value set to HardTimeout*SoftTimeoutFraction at initialisation.

Definition at line 345 of file HltEventLoopMgr.h.

m_sorHelper

std::unique_ptr<TrigSORFromPtreeHelper> HltEventLoopMgr::m_sorHelper

private

Definition at line 230 of file HltEventLoopMgr.h.

m_sorPath

Gaudi::Property<std::string> HltEventLoopMgr::m_sorPath

private

Initial value:

{
    this, "SORPath", "/TDAQ/RunCtrl/SOR_Params", "Path to StartOfRun parameters in detector store"}

Definition at line 283 of file HltEventLoopMgr.h.

m_timeoutDebugStreamName

Gaudi::Property<std::string> HltEventLoopMgr::m_timeoutDebugStreamName

private

Initial value:

{
    this, "TimeoutDebugStreamName", "HltTimeout",
    "Debug stream name for events with HLT timeout"}

Definition at line 275 of file HltEventLoopMgr.h.

m_timeoutThread

std::unique_ptr<HLT::LoopThread> HltEventLoopMgr::m_timeoutThread

private

Timeout thread.

Definition at line 343 of file HltEventLoopMgr.h.

m_timeoutThreadIntervalMs

Gaudi::Property<unsigned int> HltEventLoopMgr::m_timeoutThreadIntervalMs

private

Initial value:

{
    this, "TimeoutThreadIntervalMs", 1000, "How often the timeout thread checks for soft timeout, in milliseconds"}

Definition at line 245 of file HltEventLoopMgr.h.

m_timeoutTraceGenerated

bool HltEventLoopMgr::m_timeoutTraceGenerated {false}

private

Flag set when a soft timeout produces a stack trace, to avoid producing multiple traces.

Definition at line 355 of file HltEventLoopMgr.h.

m_traceOnTimeout

Gaudi::Property<bool> HltEventLoopMgr::m_traceOnTimeout

private

Initial value:

{
    this, "TraceOnTimeout", true,
    "Print a stack trace on the first soft timeout (might take a while, holding all threads)"}

Definition at line 248 of file HltEventLoopMgr.h.

m_truncationDebugStreamName

Gaudi::Property<std::string> HltEventLoopMgr::m_truncationDebugStreamName

private

Initial value:

{
    this, "TruncationDebugStreamName", "TruncatedHLTResult",
    "Debug stream name for events with HLT result truncation"}

Definition at line 279 of file HltEventLoopMgr.h.

m_whiteboard

SmartIF<IHiveWhiteBoard> HltEventLoopMgr::m_whiteboard

private

Definition at line 225 of file HltEventLoopMgr.h.

m_whiteboardName

Gaudi::Property<std::string> HltEventLoopMgr::m_whiteboardName

private

Initial value:

{
    this, "WhiteboardSvc", "EventDataSvc", "Name of the Whiteboard"}

Definition at line 236 of file HltEventLoopMgr.h.

m_workerID

int HltEventLoopMgr::m_workerID {0}

private

Worker ID.

Definition at line 361 of file HltEventLoopMgr.h.

m_workerPID

int HltEventLoopMgr::m_workerPID {0}

private

Worker PID.

Definition at line 363 of file HltEventLoopMgr.h.

---

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

• HltEventLoopMgr.h
• HltEventLoopMgr.cxx