#include <Path.h>

Public Types
typedef WorkersInPath::size_type	size_type

typedef hlt::HLTState	State

typedef std::shared_ptr< HLTGlobalStatus >	TrigResPtr

typedef std::vector< WorkerInPath >	WorkersInPath

Public Member Functions
int	bitPosition () const

unsigned int	bitPosition (size_type i) const

void	clearCounters ()

Worker const *	getWorker (size_type i) const

std::string const &	name () const

Path &	operator= (Path const &)=delete

	Path (int bitpos, std::string const &path_name, WorkersInPath const &workers, TrigResPtr trptr, ExceptionToActionTable const &actions, std::shared_ptr< ActivityRegistry > reg, StreamContext const *streamContext, PathContext::PathType pathType)

	Path (Path const &)

void	processOneOccurrenceAsync (WaitingTaskHolder, EventTransitionInfo const &, ServiceToken const &, StreamID const &, StreamContext const *)

template<typename T >
void	runAllModulesAsync (WaitingTaskHolder, typename T::TransitionInfoType const &, ServiceToken const &, StreamID const &, typename T::Context const *)

void	setEarlyDeleteHelpers (std::map< const Worker , EarlyDeleteHelper > const &)

void	setPathStatusInserter (PathStatusInserter pathStatusInserter, Worker pathStatusInserterWorker)

size_type	size () const

int	timesExcept () const

int	timesExcept (size_type i) const

int	timesFailed () const

int	timesFailed (size_type i) const

int	timesPassed () const

int	timesPassed (size_type i) const

int	timesRun () const

int	timesVisited (size_type i) const

Private Member Functions
void	finished (std::exception_ptr, StreamContext const *, EventTransitionInfo const &, StreamID const &)

void	handleWorkerFailure (cms::Exception &e, int nwrwue, ModuleDescription const &, std::string const &id)

void	recordStatus (int nwrwue, hlt::HLTState state)

void	runNextWorkerAsync (unsigned int iNextModuleIndex, EventTransitionInfo const &, ServiceToken const &, StreamID const &, StreamContext const *, oneapi::tbb::task_group &iGroup)

void	threadsafe_setFailedModuleInfo (int nwrwue, bool iExceptionHappened)

void	updateCounters (hlt::HLTState state)

void	workerFinished (std::exception_ptr const , unsigned int iModuleIndex, EventTransitionInfo const &, ServiceToken const &, StreamID const &, StreamContext const , oneapi::tbb::task_group &iGroup)

Static Private Member Functions
static void	exceptionContext (cms::Exception &ex, bool isEvent, bool begin, BranchType branchType, ModuleDescription const &, std::string const &id, PathContext const &)

Private Attributes
ExceptionToActionTable const *const	act_table_

std::shared_ptr< ActivityRegistry > const	actReg_

int const	bitpos_

int	failedModuleIndex_

std::atomic< unsigned int >	modulesToRun_

PathContext	pathContext_

PathStatusInserter *	pathStatusInserter_

Worker *	pathStatusInserterWorker_

std::atomic< bool >	printedException_ = false

State	state_

std::atomic< bool >	stateLock_ = false

int	timesExcept_

int	timesFailed_

int	timesPassed_

int	timesRun_

TrigResPtr const	trptr_

WaitingTaskList	waitingTasks_

WorkersInPath	workers_

Detailed Description

Definition at line 41 of file Path.h.

Member Typedef Documentation

◆ size_type

typedef WorkersInPath::size_type edm::Path::size_type

Definition at line 46 of file Path.h.

◆ State

typedef hlt::HLTState edm::Path::State

Definition at line 43 of file Path.h.

◆ TrigResPtr

typedef std::shared_ptr<HLTGlobalStatus> edm::Path::TrigResPtr

Definition at line 47 of file Path.h.

◆ WorkersInPath

typedef std::vector<WorkerInPath> edm::Path::WorkersInPath

Definition at line 45 of file Path.h.

Constructor & Destructor Documentation

◆ Path() [1/2]

edm::Path::Path	(	int	bitpos,
		std::string const &	path_name,
		WorkersInPath const &	workers,
		TrigResPtr	trptr,
		ExceptionToActionTable const &	actions,
		std::shared_ptr< ActivityRegistry >	reg,
		StreamContext const *	streamContext,
		PathContext::PathType	pathType
	)

Definition at line 19 of file Path.cc.

References modulesToRun_, pathContext_, and workers_.

       : timesRun_(),
         timesPassed_(),
         timesFailed_(),
         timesExcept_(),
         failedModuleIndex_(workers.size()),
         state_(hlt::Ready),
         bitpos_(bitpos),
         trptr_(trptr),
         actReg_(areg),
         act_table_(&actions),
         workers_(workers),
         pathContext_(path_name, streamContext, bitpos, pathType),
         pathStatusInserter_(nullptr),
         pathStatusInserterWorker_(nullptr) {
     for (auto& workerInPath : workers_) {
       workerInPath.setPathContext(&pathContext_);
     }
     modulesToRun_ = workers_.size();
   }

◆ Path() [2/2]

edm::Path::Path ( Path const & r )

Definition at line 47 of file Path.cc.

References modulesToRun_, pathContext_, and workers_.

       : timesRun_(r.timesRun_),
         timesPassed_(r.timesPassed_),
         timesFailed_(r.timesFailed_),
         timesExcept_(r.timesExcept_),
         failedModuleIndex_(r.failedModuleIndex_),
         state_(r.state_),
         bitpos_(r.bitpos_),
         trptr_(r.trptr_),
         actReg_(r.actReg_),
         act_table_(r.act_table_),
         workers_(r.workers_),
         pathContext_(r.pathContext_),
         pathStatusInserter_(r.pathStatusInserter_),
         pathStatusInserterWorker_(r.pathStatusInserterWorker_) {
     for (auto& workerInPath : workers_) {
       workerInPath.setPathContext(&pathContext_);
     }
     modulesToRun_ = workers_.size();
   }

Member Function Documentation

◆ bitPosition() [1/2]

int edm::Path::bitPosition ( ) const

inline

Definition at line 72 of file Path.h.

References bitpos_.

Referenced by finished().

72 { return bitpos_; }

edm::Path::bitpos_

int const bitpos_

Definition: Path.h:108

◆ bitPosition() [2/2]

unsigned int edm::Path::bitPosition ( size_type i ) const

inline

Definition at line 89 of file Path.h.

References mps_fire::i, and workers_.

89 { return workers_.at(i).bitPosition(); }

mps_fire.i

i

Definition: mps_fire.py:429

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:114

◆ clearCounters()

void edm::Path::clearCounters ( )

Definition at line 183 of file Path.cc.

References edm::WorkerInPath::clearCounters(), edm::for_all(), timesExcept_, timesFailed_, timesPassed_, timesRun_, and workers_.

Referenced by edm::StreamSchedule::clearCounters().

                            {
     using std::placeholders::_1;
     timesRun_ = timesPassed_ = timesFailed_ = timesExcept_ = 0;
     for_all(workers_, std::bind(&WorkerInPath::clearCounters, _1));
   }

◆ exceptionContext()

void edm::Path::exceptionContext	(	cms::Exception &	ex,
		bool	isEvent,
		bool	begin,
		BranchType	branchType,
		ModuleDescription const &	desc,
		std::string const &	id,
		PathContext const &	pathContext
	)

staticprivate

Definition at line 104 of file Path.cc.

References cms::Exception::addContext(), l1ctLayer2EG_cff::id, edm::InLumi, edm::InRun, and edm::PathContext::pathName().

Referenced by handleWorkerFailure().

                                                               {
     std::ostringstream ost;
     ost << "Running path '" << pathContext.pathName() << "'";
     ex.addContext(ost.str());
     ost.str("");
     ost << "Processing ";
     //For the event case, the Worker has already
     // added the necessary module context to the exception
     if (begin && branchType == InRun) {
       ost << "stream begin Run";
     } else if (begin && branchType == InLumi) {
       ost << "stream begin LuminosityBlock ";
     } else if (!begin && branchType == InLumi) {
       ost << "stream end LuminosityBlock ";
     } else if (!begin && branchType == InRun) {
       ost << "stream end Run ";
     } else if (isEvent) {
       // It should be impossible to get here ...
       ost << "Event ";
     }
     ost << id;
     ex.addContext(ost.str());
   }

◆ finished()

void edm::Path::finished	(	std::exception_ptr	iException,
		StreamContext const *	iContext,
		EventTransitionInfo const &	iInfo,
		StreamID const &	streamID
	)

private

Definition at line 300 of file Path.cc.

References actReg_, bitPosition(), CMS_SA_ALLOW, edm::WaitingTaskList::doneWaiting(), failedModuleIndex_, pathContext_, pathStatusInserter_, pathStatusInserterWorker_, recordStatus(), edm::Worker::runModuleDirectly(), edm::PathStatusInserter::setPathStatus(), state_, mps_update::status, updateCounters(), and waitingTasks_.

Referenced by processOneOccurrenceAsync(), and workerFinished().

                                                 {
     updateCounters(state_);
     auto failedModuleBitPosition = bitPosition(failedModuleIndex_);
     recordStatus(failedModuleBitPosition, state_);
     // Caught exception is propagated via WaitingTaskList
     CMS_SA_ALLOW try {
       HLTPathStatus status(state_, failedModuleBitPosition);
 
       if (pathStatusInserter_) {  // pathStatusInserter is null for EndPaths
         pathStatusInserter_->setPathStatus(streamID, status);
       }
       if (pathStatusInserterWorker_) {
         std::exception_ptr jException =
             pathStatusInserterWorker_->runModuleDirectly<OccurrenceTraits<EventPrincipal, BranchActionStreamBegin>>(
                 iInfo, streamID, ParentContext(iContext), iContext);
         if (jException && not iException) {
           iException = jException;
         }
       }
       actReg_->postPathEventSignal_(*iContext, pathContext_, status);
     } catch (...) {
       if (not iException) {
         iException = std::current_exception();
       }
     }
     waitingTasks_.doneWaiting(iException);
   }

◆ getWorker()

Worker const* edm::Path::getWorker ( size_type i ) const

inline

Definition at line 88 of file Path.h.

References mps_fire::i, and workers_.

Referenced by setEarlyDeleteHelpers().

88 { return workers_.at(i).getWorker(); }

mps_fire.i

i

Definition: mps_fire.py:429

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:114

◆ handleWorkerFailure()

void edm::Path::handleWorkerFailure	(	cms::Exception &	e,
		int	nwrwue,
		ModuleDescription const &	desc,
		std::string const &	id
	)

private

Definition at line 68 of file Path.cc.

References act_table_, writedatasetfile::action, edm::Exception::codeToString(), submitPVResolutionJobs::desc, MillePedeFileConverter_cfg::e, exceptionContext(), edm::ExceptionToActionTable::find(), edm::InEvent, name(), pathContext_, edm::printCmsExceptionWarning(), printedException_, edm::errors::ProductNotFound, edm::exception_actions::Rethrow, alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, and edm::exception_actions::TryToContinue.

Referenced by workerFinished().

                                                                                                                 {
     if (e.context().empty()) {
       exceptionContext(e, true /*isEvent*/, true /*begin*/, InEvent /*branchType*/, desc, id, pathContext_);
     }
     // there is no support as of yet for specific paths having
     // different exception behavior
 
     // If not processing an event, always rethrow.
     exception_actions::ActionCodes action = act_table_->find(e.category());
     switch (action) {
       case exception_actions::TryToContinue: {
         bool expected = false;
         if (printedException_.compare_exchange_strong(expected, true)) {
           std::ostringstream s;
           s << "Path " << name() << " applying TryToContinue on";
           edm::printCmsExceptionWarning(s.str().c_str(), e);
         }
         break;
       }
       default: {
         if (action == exception_actions::Rethrow) {
           std::string pNF = Exception::codeToString(errors::ProductNotFound);
           if (e.category() == pNF) {
             std::ostringstream ost;
             ost << "If you wish to continue processing events after a " << pNF << " exception,\n"
                 << "add \"TryToContinue = cms.untracked.vstring('ProductNotFound')\" to the \"options\" PSet in the "
                    "configuration.\n";
             e.addAdditionalInfo(ost.str());
           }
         }
         //throw will copy which will slice the object
         e.raise();
       }
     }
   }

◆ name()

std::string const& edm::Path::name ( void ) const

inline

Definition at line 73 of file Path.h.

References pathContext_, and edm::PathContext::pathName().

Referenced by config.CFG::__str__(), edm::StreamSchedule::availablePaths(), validation.Sample::digest(), handleWorkerFailure(), VIDSelectorBase.VIDSelectorBase::initialize(), edm::StreamSchedule::moduleDescriptionsInEndPath(), edm::StreamSchedule::moduleDescriptionsInPath(), and edm::StreamSchedule::modulesInPath().

73 { return pathContext_.pathName(); }

edm::Path::pathContext_

PathContext pathContext_

Definition: Path.h:116

edm::PathContext::pathName

std::string const & pathName() const

Definition: PathContext.h:30

◆ operator=()

Path& edm::Path::operator= ( Path const & )

delete

◆ processOneOccurrenceAsync()

void edm::Path::processOneOccurrenceAsync	(	WaitingTaskHolder	iTask,
		EventTransitionInfo const &	iInfo,
		ServiceToken const &	iToken,
		StreamID const &	iStreamID,
		StreamContext const *	iStreamContext
	)

Definition at line 203 of file Path.cc.

References actReg_, edm::WaitingTaskList::add(), failedModuleIndex_, finished(), edm::WaitingTaskHolder::group(), modulesToRun_, edm::hlt::Pass, pathContext_, printedException_, edm::WaitingTaskList::reset(), runNextWorkerAsync(), state_, timesRun_, waitingTasks_, and workers_.

                                                                             {
     waitingTasks_.reset();
     modulesToRun_ = workers_.size();
     ++timesRun_;
     waitingTasks_.add(iTask);
     printedException_ = false;
     if (actReg_) {
       ServiceRegistry::Operate guard(iToken);
       actReg_->prePathEventSignal_(*iStreamContext, pathContext_);
     }
     //If the Path succeeds, these are the values we have at the end
     state_ = hlt::Pass;
     failedModuleIndex_ = workers_.size() - 1;
 
     if (workers_.empty()) {
       ServiceRegistry::Operate guard(iToken);
       finished(std::exception_ptr(), iStreamContext, iInfo, iStreamID);
       return;
     }
 
     runNextWorkerAsync(0, iInfo, iToken, iStreamID, iStreamContext, *iTask.group());
   }

◆ recordStatus()

void edm::Path::recordStatus	(	int	nwrwue,
		hlt::HLTState	state
	)

private

Definition at line 160 of file Path.cc.

References bitpos_, and trptr_.

Referenced by finished().

                                                        {
     if (trptr_) {
       trptr_->at(bitpos_) = HLTPathStatus(state, nwrwue);
     }
   }

◆ runAllModulesAsync()

template<typename T >

void edm::Path::runAllModulesAsync	(	WaitingTaskHolder	task,
		typename T::TransitionInfoType const &	info,
		ServiceToken const &	token,
		StreamID const &	streamID,
		typename T::Context const *	context
	)

Definition at line 182 of file Path.h.

References visDQMUpload::context, info(), TrackValidation_cff::task, unpackBuffers-CaloStage2::token, and workers_.

                                                                   {
     for (auto& worker : workers_) {
       worker.runWorkerAsync<T>(task, info, token, streamID, context);
     }
   }

◆ runNextWorkerAsync()

void edm::Path::runNextWorkerAsync	(	unsigned int	iNextModuleIndex,
		EventTransitionInfo const &	iInfo,
		ServiceToken const &	iToken,
		StreamID const &	iID,
		StreamContext const *	iContext,
		oneapi::tbb::task_group &	iGroup
	)

private

Definition at line 331 of file Path.cc.

References info(), edm::ServiceWeakToken::lock(), edm::make_waiting_task(), workerFinished(), and workers_.

Referenced by processOneOccurrenceAsync(), and workerFinished().

                                                              {
     //Figure out which next modules can run concurrently
     const int firstModuleIndex = iNextModuleIndex;
     int lastModuleIndex = firstModuleIndex;
     while (lastModuleIndex + 1 != static_cast<int>(workers_.size()) and workers_[lastModuleIndex].runConcurrently()) {
       ++lastModuleIndex;
     }
     for (; lastModuleIndex >= firstModuleIndex; --lastModuleIndex) {
       ServiceWeakToken weakToken = iToken;
       auto nextTask = make_waiting_task([this, lastModuleIndex, info = iInfo, iID, iContext, weakToken, &iGroup](
                                             std::exception_ptr const* iException) {
         this->workerFinished(iException, lastModuleIndex, info, weakToken.lock(), iID, iContext, iGroup);
       });
       workers_[lastModuleIndex].runWorkerAsync<OccurrenceTraits<EventPrincipal, BranchActionStreamBegin>>(
           WaitingTaskHolder(iGroup, nextTask), iInfo, iToken, iID, iContext);
     }
   }

◆ setEarlyDeleteHelpers()

void edm::Path::setEarlyDeleteHelpers ( std::map< const Worker *, EarlyDeleteHelper *> const & iWorkerToDeleter )

Definition at line 189 of file Path.cc.

References newFWLiteAna::found, getWorker(), and size().

                                                                                                     {
     for (unsigned int index = 0; index != size(); ++index) {
       auto found = iWorkerToDeleter.find(getWorker(index));
       if (found != iWorkerToDeleter.end()) {
         found->second->addedToPath();
       }
     }
   }

◆ setPathStatusInserter()

void edm::Path::setPathStatusInserter	(	PathStatusInserter *	pathStatusInserter,
		Worker *	pathStatusInserterWorker
	)

Definition at line 198 of file Path.cc.

References pathStatusInserter_, and pathStatusInserterWorker_.

                                                                                                            {
     pathStatusInserter_ = pathStatusInserter;
     pathStatusInserterWorker_ = pathStatusInserterWorker;
   }

◆ size()

size_type edm::Path::size ( void ) const

inline

Definition at line 83 of file Path.h.

References workers_.

Referenced by ntupleDataFormat._Collection::__iter__(), ntupleDataFormat._Collection::__len__(), and setEarlyDeleteHelpers().

83 { return workers_.size(); }

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:114

◆ threadsafe_setFailedModuleInfo()

void edm::Path::threadsafe_setFailedModuleInfo	(	int	nwrwue,
		bool	iExceptionHappened
	)

private

Definition at line 134 of file Path.cc.

References edm::hlt::Exception, edm::hlt::Fail, failedModuleIndex_, state_, and stateLock_.

Referenced by workerFinished().

                                                                     {
     bool expected = false;
     while (not stateLock_.compare_exchange_strong(expected, true)) {
       expected = false;
     }
     if (iExcept) {
       if (state_ == hlt::Exception) {
         if (nwrwue < failedModuleIndex_) {
           failedModuleIndex_ = nwrwue;
         }
       } else {
         state_ = hlt::Exception;
         failedModuleIndex_ = nwrwue;
       }
     } else {
       if (state_ != hlt::Exception) {
         if (nwrwue < failedModuleIndex_) {
           failedModuleIndex_ = nwrwue;
         }
         state_ = hlt::Fail;
       }
     }
 
     stateLock_ = false;
   }

◆ timesExcept() [1/2]

int edm::Path::timesExcept ( ) const

inline

Definition at line 80 of file Path.h.

References timesExcept_.

80 { return timesExcept_; }

edm::Path::timesExcept_

int timesExcept_

Definition: Path.h:99

◆ timesExcept() [2/2]

int edm::Path::timesExcept ( size_type i ) const

inline

Definition at line 87 of file Path.h.

References mps_fire::i, and workers_.

87 { return workers_.at(i).timesExcept(); }

mps_fire.i

i

Definition: mps_fire.py:429

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:114

◆ timesFailed() [1/2]

int edm::Path::timesFailed ( ) const

inline

Definition at line 79 of file Path.h.

References timesFailed_.

79 { return timesFailed_; }

edm::Path::timesFailed_

int timesFailed_

Definition: Path.h:98

◆ timesFailed() [2/2]

int edm::Path::timesFailed ( size_type i ) const

inline

Definition at line 86 of file Path.h.

References mps_fire::i, and workers_.

86 { return workers_.at(i).timesFailed(); }

mps_fire.i

i

Definition: mps_fire.py:429

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:114

◆ timesPassed() [1/2]

int edm::Path::timesPassed ( ) const

inline

Definition at line 78 of file Path.h.

References timesPassed_.

78 { return timesPassed_; }

edm::Path::timesPassed_

int timesPassed_

Definition: Path.h:97

◆ timesPassed() [2/2]

int edm::Path::timesPassed ( size_type i ) const

inline

Definition at line 85 of file Path.h.

References mps_fire::i, and workers_.

85 { return workers_.at(i).timesPassed(); }

mps_fire.i

i

Definition: mps_fire.py:429

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:114

◆ timesRun()

int edm::Path::timesRun ( ) const

inline

Definition at line 77 of file Path.h.

References timesRun_.

77 { return timesRun_; }

edm::Path::timesRun_

int timesRun_

Definition: Path.h:96

◆ timesVisited()

int edm::Path::timesVisited ( size_type i ) const

inline

Definition at line 84 of file Path.h.

References mps_fire::i, and workers_.

84 { return workers_.at(i).timesVisited(); }

mps_fire.i

i

Definition: mps_fire.py:429

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:114

◆ updateCounters()

void edm::Path::updateCounters ( hlt::HLTState state )

private

Definition at line 166 of file Path.cc.

References edm::hlt::Exception, edm::hlt::Fail, edm::hlt::Pass, timesExcept_, timesFailed_, and timesPassed_.

Referenced by finished().

                                              {
     switch (state) {
       case hlt::Pass: {
         ++timesPassed_;
         break;
       }
       case hlt::Fail: {
         ++timesFailed_;
         break;
       }
       case hlt::Exception: {
         ++timesExcept_;
       }
       default:;
     }
   }

◆ workerFinished()

void edm::Path::workerFinished	(	std::exception_ptr const *	iException,
		unsigned int	iModuleIndex,
		EventTransitionInfo const &	iInfo,
		ServiceToken const &	iToken,
		StreamID const &	iID,
		StreamContext const *	iContext,
		oneapi::tbb::task_group &	iGroup
	)

private

Definition at line 230 of file Path.cc.

References cms::cuda::assert(), cms::Exception::clone(), CMS_SA_ALLOW, submitPVResolutionJobs::desc, cppFunctionSkipper::exception, finished(), handleWorkerFailure(), edm::EventPrincipal::id(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, modulesToRun_, edm::WaitingTaskList::presetTaskAsFailed(), edm::EventTransitionInfo::principal(), runNextWorkerAsync(), edm::errors::StdException, threadsafe_setFailedModuleInfo(), edm::errors::Unknown, waitingTasks_, and workers_.

Referenced by runNextWorkerAsync().

                                                          {
     EventPrincipal const& iEP = iInfo.principal();
     ServiceRegistry::Operate guard(iToken);
 
     //This call also allows the WorkerInPath to update statistics
     // so should be done even if an exception happened
     auto& worker = workers_[iModuleIndex];
     bool shouldContinue = worker.checkResultsOfRunWorker(true);
     std::exception_ptr finalException;
     if (iException) {
       shouldContinue = false;
       std::unique_ptr<cms::Exception> pEx;
       try {
         std::rethrow_exception(*iException);
       } catch (cms::Exception& oldEx) {
         pEx = std::unique_ptr<cms::Exception>(oldEx.clone());
       } catch (std::exception const& oldEx) {
         pEx = std::make_unique<edm::Exception>(errors::StdException);
       } catch (...) {
         pEx = std::make_unique<edm::Exception>(errors::Unknown);
       }
       // Caught exception is propagated via WaitingTaskList
       CMS_SA_ALLOW try {
         std::ostringstream ost;
         ost << iEP.id();
         ModuleDescription const* desc = worker.getWorker()->description();
         assert(desc != nullptr);
         handleWorkerFailure(*pEx, iModuleIndex, *desc, ost.str());
         //If we didn't rethrow, then we effectively skipped
         worker.skipWorker(iEP);
       } catch (...) {
         finalException = std::current_exception();
         //set the exception early to avoid case where another Path is waiting
         // on a module in this Path and not running the module will lead to a
         // different but related exception in the other Path. We want this
         // Paths exception to be the one that gets reported.
         waitingTasks_.presetTaskAsFailed(finalException);
       }
     }
     auto const nextIndex = iModuleIndex + 1;
     if (shouldContinue and nextIndex < workers_.size()) {
       if (not worker.runConcurrently()) {
         --modulesToRun_;
         runNextWorkerAsync(nextIndex, iInfo, iToken, iID, iContext, iGroup);
         return;
       }
     }
 
     if (not shouldContinue) {
       threadsafe_setFailedModuleInfo(iModuleIndex, iException != nullptr);
     }
     if (not shouldContinue and not worker.runConcurrently()) {
       //we are leaving the path early
       for (auto it = workers_.begin() + nextIndex, itEnd = workers_.end(); it != itEnd; ++it) {
         --modulesToRun_;
         it->skipWorker(iEP);
       }
     }
     if (--modulesToRun_ == 0) {
       //The path should only be marked as finished once all outstanding modules finish
       finished(finalException, iContext, iInfo, iID);
     }
   }

Member Data Documentation

◆ act_table_

ExceptionToActionTable const* const edm::Path::act_table_

private

Definition at line 112 of file Path.h.

Referenced by handleWorkerFailure().

◆ actReg_

std::shared_ptr<ActivityRegistry> const edm::Path::actReg_

private

Definition at line 111 of file Path.h.

Referenced by finished(), and processOneOccurrenceAsync().

◆ bitpos_

int const edm::Path::bitpos_

private

Definition at line 108 of file Path.h.

Referenced by bitPosition(), and recordStatus().

◆ failedModuleIndex_

int edm::Path::failedModuleIndex_

private

Definition at line 105 of file Path.h.

Referenced by finished(), processOneOccurrenceAsync(), and threadsafe_setFailedModuleInfo().

◆ modulesToRun_

std::atomic<unsigned int> edm::Path::modulesToRun_

private

Definition at line 118 of file Path.h.

Referenced by Path(), processOneOccurrenceAsync(), and workerFinished().

◆ pathContext_

PathContext edm::Path::pathContext_

private

Definition at line 116 of file Path.h.

Referenced by finished(), handleWorkerFailure(), name(), Path(), and processOneOccurrenceAsync().

◆ pathStatusInserter_

PathStatusInserter* edm::Path::pathStatusInserter_

private

Definition at line 120 of file Path.h.

Referenced by finished(), and setPathStatusInserter().

◆ pathStatusInserterWorker_

Worker* edm::Path::pathStatusInserterWorker_

private

Definition at line 121 of file Path.h.

Referenced by finished(), and setPathStatusInserter().

◆ printedException_

std::atomic<bool> edm::Path::printedException_ = false

private

Definition at line 101 of file Path.h.

Referenced by handleWorkerFailure(), and processOneOccurrenceAsync().

◆ state_

State edm::Path::state_

private

Definition at line 106 of file Path.h.

Referenced by finished(), processOneOccurrenceAsync(), and threadsafe_setFailedModuleInfo().

◆ stateLock_

std::atomic<bool> edm::Path::stateLock_ = false

private

Definition at line 104 of file Path.h.

Referenced by threadsafe_setFailedModuleInfo().

◆ timesExcept_

int edm::Path::timesExcept_

private

Definition at line 99 of file Path.h.

Referenced by clearCounters(), timesExcept(), and updateCounters().

◆ timesFailed_

int edm::Path::timesFailed_

private

Definition at line 98 of file Path.h.

Referenced by clearCounters(), timesFailed(), and updateCounters().

◆ timesPassed_

int edm::Path::timesPassed_

private

Definition at line 97 of file Path.h.

Referenced by clearCounters(), timesPassed(), and updateCounters().

◆ timesRun_

int edm::Path::timesRun_

private

Definition at line 96 of file Path.h.

Referenced by clearCounters(), processOneOccurrenceAsync(), and timesRun().

◆ trptr_

TrigResPtr const edm::Path::trptr_

private

Definition at line 109 of file Path.h.

Referenced by recordStatus().

◆ waitingTasks_

WaitingTaskList edm::Path::waitingTasks_

private

Definition at line 117 of file Path.h.

Referenced by finished(), processOneOccurrenceAsync(), and workerFinished().

◆ workers_

WorkersInPath edm::Path::workers_

private

Definition at line 114 of file Path.h.

Referenced by bitPosition(), clearCounters(), getWorker(), Path(), processOneOccurrenceAsync(), runAllModulesAsync(), runNextWorkerAsync(), size(), timesExcept(), timesFailed(), timesPassed(), timesVisited(), and workerFinished().

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ size_type

◆ State

◆ TrigResPtr

◆ WorkersInPath

Constructor & Destructor Documentation

◆ Path() [1/2]

◆ Path() [2/2]

Member Function Documentation

◆ bitPosition() [1/2]

◆ bitPosition() [2/2]

◆ clearCounters()

◆ exceptionContext()

◆ finished()

◆ getWorker()

◆ handleWorkerFailure()

◆ name()

◆ operator=()

◆ processOneOccurrenceAsync()

◆ recordStatus()

◆ runAllModulesAsync()

◆ runNextWorkerAsync()

◆ setEarlyDeleteHelpers()

◆ setPathStatusInserter()

◆ size()

◆ threadsafe_setFailedModuleInfo()

◆ timesExcept() [1/2]

◆ timesExcept() [2/2]

◆ timesFailed() [1/2]

◆ timesFailed() [2/2]

◆ timesPassed() [1/2]

◆ timesPassed() [2/2]

◆ timesRun()

◆ timesVisited()

◆ updateCounters()

◆ workerFinished()

Member Data Documentation

◆ act_table_

◆ actReg_

◆ bitpos_

◆ failedModuleIndex_

◆ modulesToRun_

◆ pathContext_

◆ pathStatusInserter_

◆ pathStatusInserterWorker_

◆ printedException_

◆ state_

◆ stateLock_

◆ timesExcept_

◆ timesFailed_

◆ timesPassed_

◆ timesRun_

◆ trptr_

◆ waitingTasks_

◆ workers_