edm::Path Class Reference

#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
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, std::atomic< bool > *stopProcessEvent, PathContext::PathType pathType)
	Path (Path const &)
void	processOneOccurrenceAsync (WaitingTask *, EventTransitionInfo const &, ServiceToken const &, StreamID const &, StreamContext const *)
template<typename T >
void	runAllModulesAsync (WaitingTask *, 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 &)
bool	handleWorkerFailure (cms::Exception &e, int nwrwue, bool isEvent, bool begin, BranchType branchType, ModuleDescription const &, std::string const &id) const
void	recordStatus (int nwrwue, hlt::HLTState state)
void	runNextWorkerAsync (unsigned int iNextModuleIndex, EventTransitionInfo const &, ServiceToken const &, StreamID const &, StreamContext const *)
void	threadsafe_setFailedModuleInfo (int nwrwue, std::exception_ptr)
void	updateCounters (hlt::HLTState state)
void	workerFinished (std::exception_ptr const *, unsigned int iModuleIndex, EventTransitionInfo const &, ServiceToken const &, StreamID const &, StreamContext const *)

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_
const std::shared_ptr< ActivityRegistry >	actReg_
const int	bitpos_
int	failedModuleIndex_
std::atomic< unsigned int >	modulesToRun_
PathContext	pathContext_
PathStatusInserter *	pathStatusInserter_
Worker *	pathStatusInserterWorker_
State	state_
std::atomic< bool >	stateLock_ = false
std::atomic< bool > *const	stopProcessingEvent_
int	timesExcept_
int	timesFailed_
int	timesPassed_
int	timesRun_
const TrigResPtr	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,
		std::atomic< bool > *	stopProcessEvent,
		PathContext::PathType	pathType
	)

Definition at line 18 of file Path.cc.

      : 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),
        stopProcessingEvent_(stopProcessingEvent),
        pathStatusInserter_(nullptr),
        pathStatusInserterWorker_(nullptr) {
    for (auto& workerInPath : workers_) {
      workerInPath.setPathContext(&pathContext_);
    }
    modulesToRun_ = workers_.size();
  }

References modulesToRun_, pathContext_, and workers_.

Path() [2/2]

edm::Path::Path

(

Path const &

r

)

Definition at line 48 of file Path.cc.

      : 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_),
        stopProcessingEvent_(r.stopProcessingEvent_),
        pathStatusInserter_(r.pathStatusInserter_),
        pathStatusInserterWorker_(r.pathStatusInserterWorker_) {
    for (auto& workerInPath : workers_) {
      workerInPath.setPathContext(&pathContext_);
    }
    modulesToRun_ = workers_.size();
  }

References modulesToRun_, pathContext_, and workers_.

Member Function Documentation

bitPosition()

int edm::Path::bitPosition ( ) const

inline

Definition at line 73 of file Path.h.

{ return bitpos_; }

References bitpos_.

clearCounters()

void edm::Path::clearCounters

(

)

Definition at line 198 of file Path.cc.

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

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

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

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 119 of file Path.cc.

                                                              {
    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());
  }

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

Referenced by handleWorkerFailure().

finished()

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

private

Definition at line 317 of file Path.cc.

                                                {
    updateCounters(state_);
    recordStatus(failedModuleIndex_, state_);
    // Caught exception is propagated via WaitingTaskList
    CMS_SA_ALLOW try {
      HLTPathStatus status(state_, failedModuleIndex_);
 
      if (pathStatusInserter_) {  // pathStatusInserter is null for EndPaths
        pathStatusInserter_->setPathStatus(streamID, status);
      }
      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);
  }

References actReg_, 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().

getWorker()

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

inline

Definition at line 89 of file Path.h.

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

References mps_fire::i, and workers_.

Referenced by setEarlyDeleteHelpers().

handleWorkerFailure()

bool edm::Path::handleWorkerFailure ( cms::Exception &  e, int  nwrwue, bool  isEvent, bool  begin, BranchType  branchType, ModuleDescription const &  desc, std::string const &  id  ) const

private

Definition at line 70 of file Path.cc.

                                                            {
    if (e.context().empty()) {
      exceptionContext(e, isEvent, begin, branchType, desc, id, pathContext_);
    }
    bool should_continue = true;
 
    // 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 = (isEvent ? act_table_->find(e.category()) : exception_actions::Rethrow);
    switch (action) {
      case exception_actions::FailPath: {
        should_continue = false;
        edm::printCmsExceptionWarning("FailPath", e);
        break;
      }
      case exception_actions::SkipEvent: {
        //Need the other Paths to stop as soon as possible
        if (stopProcessingEvent_) {
          *stopProcessingEvent_ = true;
        }
        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 \"SkipEvent = 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();
      }
    }
 
    return should_continue;
  }

References act_table_, writedatasetfile::action, edm::Exception::codeToString(), submitPVResolutionJobs::desc, MillePedeFileConverter_cfg::e, exceptionContext(), edm::exception_actions::FailPath, edm::ExceptionToActionTable::find(), pathContext_, edm::printCmsExceptionWarning(), edm::errors::ProductNotFound, edm::exception_actions::Rethrow, edm::exception_actions::SkipEvent, stopProcessingEvent_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by workerFinished().

name()

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

inline

Definition at line 74 of file Path.h.

{ return pathContext_.pathName(); }

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

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

operator=()

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

delete

processOneOccurrenceAsync()

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

Definition at line 218 of file Path.cc.

                                                                            {
    waitingTasks_.reset();
    modulesToRun_ = workers_.size();
    ++timesRun_;
    waitingTasks_.add(iTask);
    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);
  }

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

recordStatus()

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

private

Definition at line 175 of file Path.cc.

                                                       {
    if (trptr_) {
      (*trptr_)[bitpos_] = HLTPathStatus(state, nwrwue);
    }
  }

References bitpos_, and trptr_.

Referenced by finished().

runAllModulesAsync()

template<typename T >

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

Definition at line 186 of file Path.h.

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

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

runNextWorkerAsync()

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

private

Definition at line 345 of file Path.cc.

                                                               {
    //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) {
      auto nextTask = make_waiting_task(
          tbb::task::allocate_root(),
          [this, lastModuleIndex, info = iInfo, iID, iContext, token = iToken](std::exception_ptr const* iException) {
            this->workerFinished(iException, lastModuleIndex, info, token, iID, iContext);
          });
      workers_[lastModuleIndex].runWorkerAsync<OccurrenceTraits<EventPrincipal, BranchActionStreamBegin>>(
          nextTask, iInfo, iToken, iID, iContext);
    }
  }

References info(), edm::make_waiting_task(), unpackBuffers-CaloStage2::token, workerFinished(), and workers_.

Referenced by processOneOccurrenceAsync(), and workerFinished().

setEarlyDeleteHelpers()

void edm::Path::setEarlyDeleteHelpers

(

std::map< const Worker *, EarlyDeleteHelper * > const &

iWorkerToDeleter

)

Definition at line 204 of file Path.cc.

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

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

setPathStatusInserter()

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

Definition at line 213 of file Path.cc.

                                                                                                           {
    pathStatusInserter_ = pathStatusInserter;
    pathStatusInserterWorker_ = pathStatusInserterWorker;
  }

References pathStatusInserter_, and pathStatusInserterWorker_.

size()

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

inline

Definition at line 84 of file Path.h.

{ return workers_.size(); }

References workers_.

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

threadsafe_setFailedModuleInfo()

void edm::Path::threadsafe_setFailedModuleInfo ( int  nwrwue, std::exception_ptr  iExcept  )

private

Definition at line 149 of file Path.cc.

                                                                                {
    bool expected = false;
    while (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;
  }

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

Referenced by workerFinished().

timesExcept() [1/2]

int edm::Path::timesExcept ( ) const

inline

Definition at line 81 of file Path.h.

{ return timesExcept_; }

References timesExcept_.

timesExcept() [2/2]

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

inline

Definition at line 88 of file Path.h.

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

References mps_fire::i, and workers_.

timesFailed() [1/2]

int edm::Path::timesFailed ( ) const

inline

Definition at line 80 of file Path.h.

{ return timesFailed_; }

References timesFailed_.

timesFailed() [2/2]

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

inline

Definition at line 87 of file Path.h.

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

References mps_fire::i, and workers_.

timesPassed() [1/2]

int edm::Path::timesPassed ( ) const

inline

Definition at line 79 of file Path.h.

{ return timesPassed_; }

References timesPassed_.

timesPassed() [2/2]

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

inline

Definition at line 86 of file Path.h.

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

References mps_fire::i, and workers_.

timesRun()

int edm::Path::timesRun ( ) const

inline

Definition at line 78 of file Path.h.

{ return timesRun_; }

References timesRun_.

timesVisited()

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

inline

Definition at line 85 of file Path.h.

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

References mps_fire::i, and workers_.

updateCounters()

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

private

Definition at line 181 of file Path.cc.

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

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

Referenced by finished().

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  )

private

Definition at line 244 of file Path.cc.

                                                           {
    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) {
      std::unique_ptr<cms::Exception> pEx;
      try {
        std::rethrow_exception(*iException);
      } catch (cms::Exception& oldEx) {
        pEx = std::unique_ptr<cms::Exception>(oldEx.clone());
      }
      // Caught exception is propagated via WaitingTaskList
      CMS_SA_ALLOW try {
        std::ostringstream ost;
        ost << iEP.id();
        shouldContinue = handleWorkerFailure(*pEx,
                                             iModuleIndex,
                                             /*isEvent*/ true,
                                             /*isBegin*/ true,
                                             InEvent,
                                             worker.getWorker()->description(),
                                             ost.str());
        //If we didn't rethrow, then we effectively skipped
        worker.skipWorker(iEP);
        finalException = std::exception_ptr();
      } catch (...) {
        shouldContinue = false;
        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);
      }
    }
    if (stopProcessingEvent_ and *stopProcessingEvent_) {
      shouldContinue = false;
    }
    auto const nextIndex = iModuleIndex + 1;
    if (shouldContinue and nextIndex < workers_.size()) {
      if (not worker.runConcurrently()) {
        --modulesToRun_;
        runNextWorkerAsync(nextIndex, iInfo, iToken, iID, iContext);
        return;
      }
    }
 
    if (not shouldContinue) {
      threadsafe_setFailedModuleInfo(iModuleIndex, finalException);
    }
    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);
    }
  }

References cms::Exception::clone(), CMS_SA_ALLOW, finished(), handleWorkerFailure(), edm::EventPrincipal::id(), edm::InEvent, modulesToRun_, edm::WaitingTaskList::presetTaskAsFailed(), edm::EventTransitionInfo::principal(), runNextWorkerAsync(), stopProcessingEvent_, threadsafe_setFailedModuleInfo(), waitingTasks_, and workers_.

Referenced by runNextWorkerAsync().

Member Data Documentation

act_table_

ExceptionToActionTable const* const edm::Path::act_table_

private

Definition at line 111 of file Path.h.

Referenced by handleWorkerFailure().

actReg_

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

private

Definition at line 110 of file Path.h.

Referenced by finished(), and processOneOccurrenceAsync().

bitpos_

const int edm::Path::bitpos_

private

Definition at line 107 of file Path.h.

Referenced by bitPosition(), and recordStatus().

failedModuleIndex_

int edm::Path::failedModuleIndex_

private

Definition at line 104 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 115 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().

state_

State edm::Path::state_

private

Definition at line 105 of file Path.h.

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

stateLock_

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

private

Definition at line 103 of file Path.h.

Referenced by threadsafe_setFailedModuleInfo().

stopProcessingEvent_

std::atomic<bool>* const edm::Path::stopProcessingEvent_

private

Definition at line 117 of file Path.h.

Referenced by handleWorkerFailure(), and workerFinished().

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_

const TrigResPtr edm::Path::trptr_

private

Definition at line 108 of file Path.h.

Referenced by recordStatus().

waitingTasks_

WaitingTaskList edm::Path::waitingTasks_

private

Definition at line 116 of file Path.h.

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

workers_

WorkersInPath edm::Path::workers_

private

Definition at line 113 of file Path.h.

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