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 (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 &)
template<typename T >
void	processOneOccurrence (typename T::MyPrincipal const &, EventSetup const &, StreamID const &, typename T::Context const *)
void	processOneOccurrenceAsync (WaitingTask *, EventPrincipal const &, EventSetup const &, StreamID const &, StreamContext const *)
template<typename T >
void	runAllModulesAsync (WaitingTask *, typename T::MyPrincipal const &, EventSetup 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
State	state () 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 (int iModuleIndex, bool iSucceeded, std::exception_ptr, StreamContext const *, EventPrincipal const &iEP, EventSetup const &iES, StreamID const &streamID)
void	handleEarlyFinish (EventPrincipal const &)
void	handleEarlyFinish (RunPrincipal const &)
void	handleEarlyFinish (LuminosityBlockPrincipal const &)
bool	handleWorkerFailure (cms::Exception &e, int nwrwue, bool isEvent, bool begin, BranchType branchType, ModuleDescription const &, std::string const &id)
Path const &	operator= (Path const &)=delete
void	recordStatus (int nwrwue, bool isEvent)
void	runNextWorkerAsync (unsigned int iNextModuleIndex, EventPrincipal const &, EventSetup const &, StreamID const &, StreamContext const *)
void	updateCounters (bool succeed, bool isEvent)
void	workerFinished (std::exception_ptr const *iException, unsigned int iModuleIndex, EventPrincipal const &iEP, EventSetup const &iES, StreamID const &iID, StreamContext const *iContext)

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 *	act_table_
std::shared_ptr< ActivityRegistry >	actReg_
int	bitpos_
std::vector< EarlyDeleteHelper * >	earlyDeleteHelpers_
PathContext	pathContext_
PathStatusInserter *	pathStatusInserter_
Worker *	pathStatusInserterWorker_
State	state_
std::atomic< bool > *	stopProcessingEvent_
int	timesExcept_
int	timesFailed_
int	timesPassed_
int	timesRun_
TrigResPtr	trptr_
WaitingTaskList	waitingTasks_
WorkersInPath	workers_

Detailed Description

Definition at line 44 of file Path.h.

Member Typedef Documentation

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

Definition at line 49 of file Path.h.

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

Definition at line 46 of file Path.h.

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

Definition at line 50 of file Path.h.

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

Definition at line 48 of file Path.h.

Constructor & Destructor Documentation

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

References pathContext_, and workers_.

                                           :
    timesRun_(),
    timesPassed_(),
    timesFailed_(),
    timesExcept_(),
    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_);
    }
  }

edm::Path::Path

(

Path const &

r

)

Definition at line 43 of file Path.cc.

References pathContext_, and workers_.

                          :
    timesRun_(r.timesRun_),
    timesPassed_(r.timesPassed_),
    timesFailed_(r.timesFailed_),
    timesExcept_(r.timesExcept_),
    state_(r.state_),
    bitpos_(r.bitpos_),
    trptr_(r.trptr_),
    actReg_(r.actReg_),
    act_table_(r.act_table_),
    workers_(r.workers_),
    earlyDeleteHelpers_(r.earlyDeleteHelpers_),
    pathContext_(r.pathContext_),
    stopProcessingEvent_(r.stopProcessingEvent_),
    pathStatusInserter_(r.pathStatusInserter_),
    pathStatusInserterWorker_(r.pathStatusInserterWorker_) {

    for (auto& workerInPath : workers_) {
      workerInPath.setPathContext(&pathContext_);
    }
  }

Member Function Documentation

int edm::Path::bitPosition ( ) const

inline

Definition at line 76 of file Path.h.

References bitpos_.

Referenced by edm::fillPathSummary().

{ return bitpos_; }

void edm::Path::clearCounters

(

)

Definition at line 171 of file Path.cc.

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

Referenced by edm::StreamSchedule::clearCounters(), and name().

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

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

References cms::Exception::addContext(), hcalTTPDigis_cfi::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());
  }

void edm::Path::finished ( int  iModuleIndex, bool  iSucceeded, std::exception_ptr  iException, StreamContext const *  iContext, EventPrincipal const &  iEP, EventSetup const &  iES, StreamID const &  streamID  )

private

Definition at line 282 of file Path.cc.

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

Referenced by processOneOccurrenceAsync(), and workerFinished().

                                           {
    
    if(not iException) {
      updateCounters(iSucceeded, true);
      recordStatus(iModuleIndex, true);
    }
    try {
      HLTPathStatus status(state_, iModuleIndex);

      if (pathStatusInserter_) { // pathStatusInserter is null for EndPaths
        pathStatusInserter_->setPathStatus(streamID, status);
      }
      std::exception_ptr jException =
        pathStatusInserterWorker_->runModuleDirectly<OccurrenceTraits<EventPrincipal,
                                                                      BranchActionStreamBegin>>(
          iEP, iES, 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);
  }

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

inline

Definition at line 93 of file Path.h.

References operator=(), setEarlyDeleteHelpers(), setPathStatusInserter(), and workers_.

Referenced by edm::fillModuleInPathSummary(), and setEarlyDeleteHelpers().

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

void edm::Path::handleEarlyFinish ( EventPrincipal const &  iEvent )

private

Definition at line 202 of file Path.cc.

References earlyDeleteHelpers_.

Referenced by processOneOccurrence(), and workerFinished().

                                                      {
    for(auto helper: earlyDeleteHelpers_) {
      helper->pathFinished(iEvent);
    }
  }

void edm::Path::handleEarlyFinish ( RunPrincipal const &  )

inlineprivate

Definition at line 154 of file Path.h.

{}

void edm::Path::handleEarlyFinish ( LuminosityBlockPrincipal const &  )

inlineprivate

Definition at line 155 of file Path.h.

References a, pathContext_, runNextWorkerAsync(), state(), state_, mps_update::status, and workerFinished().

{}

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

private

Definition at line 67 of file Path.cc.

References act_table_, mps_alisetup::action, cms::Exception::addAdditionalInfo(), cms::Exception::category(), edm::Exception::codeToString(), cms::Exception::context(), edm::hlt::Exception, exceptionContext(), edm::exception_actions::FailPath, edm::ExceptionToActionTable::find(), pathContext_, edm::printCmsExceptionWarning(), edm::errors::ProductNotFound, cms::Exception::raise(), recordStatus(), edm::exception_actions::Rethrow, edm::exception_actions::SkipEvent, state_, stopProcessingEvent_, AlCaHLTBitMon_QueryRunRegistry::string, and timesExcept_.

Referenced by processOneOccurrence(), and workerFinished().

                                                 {
    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;
        }
      }
      default: {
      if (isEvent) ++timesExcept_;
      state_ = hlt::Exception;
      recordStatus(nwrwue, isEvent);
      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;
  }

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

inline

Definition at line 77 of file Path.h.

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

Referenced by config.CFG::__str__(), edm::StreamSchedule::availablePaths(), validation.Sample::digest(), edm::fillPathSummary(), VIDSelectorBase.VIDSelectorBase::initialize(), edm::StreamSchedule::moduleDescriptionsInEndPath(), edm::StreamSchedule::moduleDescriptionsInPath(), edm::StreamSchedule::modulesInPath(), and Vispa.Views.PropertyView.Property::valueChanged().

{ return pathContext_.pathName(); }

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

privatedelete

Referenced by getWorker().

template<typename T >

void edm::Path::processOneOccurrence	(	typename T::MyPrincipal const &	ep,
		EventSetup const &	es,
		StreamID const &	streamID,
		typename T::Context const *	context
	)

Definition at line 203 of file Path.h.

References actReg_, end, handleEarlyFinish(), handleWorkerFailure(), mps_fire::i, edm::make_sentry(), pathContext_, edm::hlt::Ready, recordStatus(), state_, timesRun_, updateCounters(), workers_, and edm::convertException::wrap().

                                                                                              {

    int nwrwue = -1;
    PathSignalSentry<T> signaler(actReg_.get(), nwrwue, state_, &pathContext_);

    if (T::isEvent_) {
      ++timesRun_;
    }
    state_ = hlt::Ready;

    // nwrue =  numWorkersRunWithoutUnhandledException
    bool should_continue = true;
    WorkersInPath::iterator i = workers_.begin(), end = workers_.end();
    
    auto earlyFinishSentry = make_sentry(this,[&i,end, &ep](Path*){
      for(auto j=i; j!= end;++j) {
        j->skipWorker(ep);
      }
    });
    for (;
          i != end && should_continue;
          ++i) {
      ++nwrwue;
      try {
        convertException::wrap([&]() {
            should_continue = i->runWorker<T>(ep, es, streamID, context);
        });
      }
      catch(cms::Exception& ex) {
        // handleWorkerFailure may throw a new exception.
    std::ostringstream ost;
        ost << ep.id();
        should_continue = handleWorkerFailure(ex, nwrwue, T::isEvent_, T::begin_, T::branchType_,
                                              i->getWorker()->description(), ost.str());
        //If we didn't rethrow, then we effectively skipped
        i->skipWorker(ep);
      }
    }
    if (not should_continue) {
      handleEarlyFinish(ep);
    }
    updateCounters(should_continue, T::isEvent_);
    recordStatus(nwrwue, T::isEvent_);
  }

void edm::Path::processOneOccurrenceAsync	(	WaitingTask *	iTask,
		EventPrincipal const &	iEP,
		EventSetup const &	iES,
		StreamID const &	iStreamID,
		StreamContext const *	iStreamContext
	)

Definition at line 209 of file Path.cc.

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

                                                                       {
    waitingTasks_.reset();
    ++timesRun_;
    waitingTasks_.add(iTask);
    if(actReg_) {
      actReg_->prePathEventSignal_(*iStreamContext, pathContext_);
    }
    state_ = hlt::Ready;
    
    if(workers_.empty()) {
      finished(-1, true, std::exception_ptr(), iStreamContext, iEP, iES, iStreamID);
      return;
    }
    
    runNextWorkerAsync(0,iEP,iES,iStreamID, iStreamContext);
  }

void edm::Path::recordStatus ( int  nwrwue, bool  isEvent  )

private

Definition at line 153 of file Path.cc.

References bitpos_, state_, and trptr_.

Referenced by finished(), handleWorkerFailure(), and processOneOccurrence().

                                             {
    if(isEvent && trptr_) {
      (*trptr_)[bitpos_]=HLTPathStatus(state_, nwrwue);    
    }
  }

template<typename T >

void edm::Path::runAllModulesAsync	(	WaitingTask *	task,
		typename T::MyPrincipal const &	p,
		EventSetup const &	es,
		StreamID const &	streamID,
		typename T::Context const *	context
	)

Definition at line 192 of file Path.h.

References AlCaHLTBitMon_ParallelJobs::p, and workers_.

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

void edm::Path::runNextWorkerAsync ( unsigned int  iNextModuleIndex, EventPrincipal const &  iEP, EventSetup const &  iES, StreamID const &  iID, StreamContext const *  iContext  )

private

Definition at line 315 of file Path.cc.

References edm::ServiceRegistry::instance(), edm::make_waiting_task(), edm::ServiceRegistry::presentToken(), workerFinished(), and workers_.

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

                                                                               {
    
    //need to make sure Service system is activated on the reading thread
    auto token = ServiceRegistry::instance().presentToken();

    auto nextTask = make_waiting_task( tbb::task::allocate_root(),
                                      [this, iNextModuleIndex, &iEP,&iES, iID, iContext, token](std::exception_ptr const* iException)
    {
      ServiceRegistry::Operate guard(token);
      this->workerFinished(iException, iNextModuleIndex, iEP,iES,iID,iContext);
    });
    
    workers_[iNextModuleIndex].runWorkerAsync<
    OccurrenceTraits<EventPrincipal, BranchActionStreamBegin>>(nextTask,
                                                                iEP,
                                                                iES,
                                                                iID,
                                                                iContext);
  }

void edm::Path::setEarlyDeleteHelpers

(

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

iWorkerToDeleter

)

Definition at line 178 of file Path.cc.

References earlyDeleteHelpers_, runEdmFileComparison::found, getWorker(), diffTreeTool::index, size(), and groupFilesInBlocks::temp.

Referenced by getWorker().

                                                                                              {
    //we use a temp so we can overset the size but then when moving to earlyDeleteHelpers we only
    // have to use the space necessary
    std::vector<EarlyDeleteHelper*> temp;
    temp.reserve(iWorkerToDeleter.size());
    for(unsigned int index=0; index !=size();++index) {
      auto found = iWorkerToDeleter.find(getWorker(index));
      if(found != iWorkerToDeleter.end()) {
        temp.push_back(found->second);
        found->second->addedToPath();
      }
    }
    std::vector<EarlyDeleteHelper*> tempCorrectSize(temp.begin(),temp.end());
    earlyDeleteHelpers_.swap(tempCorrectSize);
  }

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

Definition at line 195 of file Path.cc.

References pathStatusInserter_, and pathStatusInserterWorker_.

Referenced by getWorker().

                                                                {
    pathStatusInserter_ = pathStatusInserter;
    pathStatusInserterWorker_ = pathStatusInserterWorker;
  }

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

inline

Definition at line 88 of file Path.h.

References workers_.

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

{ return workers_.size(); }

State edm::Path::state ( ) const

inline

Definition at line 86 of file Path.h.

References state_.

Referenced by handleEarlyFinish().

{ return state_; }

int edm::Path::timesExcept ( ) const

inline

Definition at line 84 of file Path.h.

References timesExcept_.

Referenced by edm::fillModuleInPathSummary(), and edm::fillPathSummary().

{ return timesExcept_; }

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

inline

Definition at line 92 of file Path.h.

References workers_.

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

int edm::Path::timesFailed ( ) const

inline

Definition at line 83 of file Path.h.

References timesFailed_.

Referenced by edm::fillModuleInPathSummary(), and edm::fillPathSummary().

{ return timesFailed_; }

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

inline

Definition at line 91 of file Path.h.

References workers_.

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

int edm::Path::timesPassed ( ) const

inline

Definition at line 82 of file Path.h.

References timesPassed_.

Referenced by edm::fillModuleInPathSummary(), and edm::fillPathSummary().

{ return timesPassed_; }

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

inline

Definition at line 90 of file Path.h.

References workers_.

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

int edm::Path::timesRun ( ) const

inline

Definition at line 81 of file Path.h.

References timesRun_.

Referenced by edm::fillPathSummary().

{ return timesRun_; }

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

inline

Definition at line 89 of file Path.h.

References workers_.

Referenced by edm::fillModuleInPathSummary().

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

void edm::Path::updateCounters ( bool  succeed, bool  isEvent  )

private

Definition at line 160 of file Path.cc.

References edm::hlt::Fail, edm::hlt::Pass, state_, timesFailed_, and timesPassed_.

Referenced by finished(), and processOneOccurrence().

                                                 {
    if (success) {
      if (isEvent) ++timesPassed_;
      state_ = hlt::Pass;
    } else {
      if(isEvent) ++timesFailed_;
      state_ = hlt::Fail;
    }
  }

void edm::Path::workerFinished ( std::exception_ptr const *  iException, unsigned int  iModuleIndex, EventPrincipal const &  iEP, EventSetup const &  iES, StreamID const &  iID, StreamContext const *  iContext  )

private

Definition at line 231 of file Path.cc.

References cms::Exception::clone(), finished(), handleEarlyFinish(), handleWorkerFailure(), edm::EventPrincipal::id(), edm::InEvent, runNextWorkerAsync(), stopProcessingEvent_, and workers_.

Referenced by handleEarlyFinish(), and runNextWorkerAsync().

                                                                           {
    
    //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());
      }
      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();
      }
    }
    if(stopProcessingEvent_ and *stopProcessingEvent_) {
      shouldContinue = false;
    }
    auto const nextIndex = iModuleIndex +1;
    if (shouldContinue and nextIndex < workers_.size()) {
      runNextWorkerAsync(nextIndex, iEP, iES, iID, iContext);
      return;
    }
    
    if (not shouldContinue) {
      //we are leaving the path early
      for(auto it = workers_.begin()+nextIndex, itEnd=workers_.end();
          it != itEnd; ++it) {
        it->skipWorker(iEP);
      }
      handleEarlyFinish(iEP);
    }
    finished(iModuleIndex, shouldContinue, finalException, iContext, iEP, iES, iID);
  }

Member Data Documentation

ExceptionToActionTable const* edm::Path::act_table_

private

Definition at line 116 of file Path.h.

Referenced by handleWorkerFailure().

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

private

Definition at line 115 of file Path.h.

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

int edm::Path::bitpos_

private

Definition at line 113 of file Path.h.

Referenced by bitPosition(), and recordStatus().

std::vector<EarlyDeleteHelper*> edm::Path::earlyDeleteHelpers_

private

Definition at line 119 of file Path.h.

Referenced by handleEarlyFinish(), and setEarlyDeleteHelpers().

PathContext edm::Path::pathContext_

private

Definition at line 121 of file Path.h.

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

PathStatusInserter* edm::Path::pathStatusInserter_

private

Definition at line 125 of file Path.h.

Referenced by finished(), and setPathStatusInserter().

Worker* edm::Path::pathStatusInserterWorker_

private

Definition at line 126 of file Path.h.

Referenced by finished(), and setPathStatusInserter().

State edm::Path::state_

private

Definition at line 111 of file Path.h.

Referenced by finished(), handleEarlyFinish(), handleWorkerFailure(), processOneOccurrence(), processOneOccurrenceAsync(), recordStatus(), state(), and updateCounters().

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

private

Definition at line 123 of file Path.h.

Referenced by handleWorkerFailure(), and workerFinished().

int edm::Path::timesExcept_

private

Definition at line 109 of file Path.h.

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

int edm::Path::timesFailed_

private

Definition at line 108 of file Path.h.

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

int edm::Path::timesPassed_

private

Definition at line 107 of file Path.h.

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

int edm::Path::timesRun_

private

Definition at line 106 of file Path.h.

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

TrigResPtr edm::Path::trptr_

private

Definition at line 114 of file Path.h.

Referenced by recordStatus().

WaitingTaskList edm::Path::waitingTasks_

private

Definition at line 122 of file Path.h.

Referenced by finished(), and processOneOccurrenceAsync().

WorkersInPath edm::Path::workers_

private

Definition at line 118 of file Path.h.

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