edm::Worker Class Reference

#include <Worker.h>

Inheritance diagram for edm::Worker:

Classes
class	RunModuleTask
class	TransitionIDValue
class	TransitionIDValueBase

Public Types
enum	State { Ready, Pass, Fail, Exception }
enum	Types { kAnalyzer, kFilter, kProducer, kOutputModule }

Public Member Functions
void	addedToPath ()
void	beginJob ()
void	beginStream (StreamID id, StreamContext &streamContext)
void	callWhenDoneAsync (WaitingTask *task)
void	clearCounters ()
virtual std::vector< ConsumesInfo >	consumesInfo () const =0
virtual void	convertCurrentProcessAlias (std::string const &processName)=0
ModuleDescription const *	descPtr () const
ModuleDescription const &	description () const
template<typename T >
bool	doWork (typename T::MyPrincipal const &, EventSetup const &c, StreamID stream, ParentContext const &parentContext, typename T::Context const *context)
template<typename T >
void	doWorkAsync (WaitingTask *task, typename T::MyPrincipal const &, EventSetup const &c, StreamID stream, ParentContext const &parentContext, typename T::Context const *context)
template<typename T >
void	doWorkNoPrefetchingAsync (WaitingTask *task, typename T::MyPrincipal const &, EventSetup const &c, StreamID stream, ParentContext const &parentContext, typename T::Context const *context)
void	endJob ()
void	endStream (StreamID id, StreamContext &streamContext)
virtual void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc) const =0
virtual Types	moduleType () const =0
Worker &	operator= (Worker const &)=delete
void	postDoEvent (EventPrincipal const &)
void	registerThinnedAssociations (ProductRegistry const &registry, ThinnedAssociationsHelper &helper)
void	reset ()
virtual void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies)=0
void	respondToCloseInputFile (FileBlock const &fb)
void	respondToOpenInputFile (FileBlock const &fb)
template<typename T >
std::exception_ptr	runModuleDirectly (typename T::MyPrincipal const &ep, EventSetup const &es, StreamID streamID, ParentContext const &parentContext, typename T::Context const *context)
void	setActivityRegistry (std::shared_ptr< ActivityRegistry > areg)
void	setEarlyDeleteHelper (EarlyDeleteHelper *iHelper)
void	skipOnPath ()
State	state () const
int	timesExcept () const
int	timesFailed () const
int	timesPass () const
int	timesPassed () const
int	timesRun () const
int	timesVisited () const
virtual void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &)=0
	Worker (ModuleDescription const &iMD, ExceptionToActionTable const *iActions)
	Worker (Worker const &)=delete
virtual	~Worker ()

Protected Member Functions
ActivityRegistry *	activityRegistry ()
virtual void	implBeginJob ()=0
virtual void	implBeginStream (StreamID)=0
virtual bool	implDo (EventPrincipal const &, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual bool	implDoBegin (RunPrincipal const &rp, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual bool	implDoBegin (LuminosityBlockPrincipal const &lbp, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual bool	implDoEnd (RunPrincipal const &rp, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual bool	implDoEnd (LuminosityBlockPrincipal const &lbp, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual bool	implDoPrePrefetchSelection (StreamID id, EventPrincipal const &ep, ModuleCallingContext const *mcc)=0
virtual bool	implDoStreamBegin (StreamID id, RunPrincipal const &rp, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual bool	implDoStreamBegin (StreamID id, LuminosityBlockPrincipal const &lbp, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual bool	implDoStreamEnd (StreamID id, RunPrincipal const &rp, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual bool	implDoStreamEnd (StreamID id, LuminosityBlockPrincipal const &lbp, EventSetup const &c, ModuleCallingContext const *mcc)=0
virtual void	implEndJob ()=0
virtual void	implEndStream (StreamID)=0
void	resetModuleDescription (ModuleDescription const *)
virtual std::string	workerType () const =0

Private Member Functions
void	emitPostModuleEventPrefetchingSignal ()
virtual void	implRegisterThinnedAssociations (ProductRegistry const &, ThinnedAssociationsHelper &)=0
virtual void	implRespondToCloseInputFile (FileBlock const &fb)=0
virtual void	implRespondToOpenInputFile (FileBlock const &fb)=0
virtual void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const =0
virtual std::vector< ProductResolverIndex > const &	itemsShouldPutInEvent () const =0
virtual void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const =0
virtual std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType) const =0
virtual void	preActionBeforeRunEventAsync (WaitingTask *iTask, ModuleCallingContext const &moduleCallingContext, Principal const &iPrincipal) const =0
void	prefetchAsync (WaitingTask *, ParentContext const &parentContext, Principal const &)
template<typename T >
bool	runModule (typename T::MyPrincipal const &, EventSetup const &c, StreamID stream, ParentContext const &parentContext, typename T::Context const *context)
template<typename T >
std::exception_ptr	runModuleAfterAsyncPrefetch (std::exception_ptr const *iEPtr, typename T::MyPrincipal const &ep, EventSetup const &es, StreamID streamID, ParentContext const &parentContext, typename T::Context const *context)
virtual SerialTaskQueueChain *	serializeRunModule ()=0
template<bool IS_EVENT>
std::exception_ptr	setException (std::exception_ptr iException)
template<bool IS_EVENT>
bool	setFailed ()
template<bool IS_EVENT>
bool	setPassed ()
bool	shouldRethrowException (std::exception_ptr iPtr, ParentContext const &parentContext, bool isEvent, TransitionIDValueBase const &iID) const

Static Private Member Functions
static void	exceptionContext (cms::Exception &ex, ModuleCallingContext const *mcc)

Private Attributes
ExceptionToActionTable const *	actions_
std::shared_ptr< ActivityRegistry >	actReg_
std::exception_ptr	cached_exception_
edm::propagate_const< EarlyDeleteHelper * >	earlyDeleteHelper_
ModuleCallingContext	moduleCallingContext_
std::atomic< int >	numberOfPathsLeftToRun_
int	numberOfPathsOn_
std::atomic< State >	state_
std::atomic< int >	timesExcept_
std::atomic< int >	timesFailed_
std::atomic< int >	timesPassed_
std::atomic< int >	timesRun_
std::atomic< int >	timesVisited_
edm::WaitingTaskList	waitingTasks_
std::atomic< bool >	workStarted_

Friends
template<typename O >
class	workerhelper::CallImpl

Detailed Description

Definition at line 77 of file Worker.h.

Member Enumeration Documentation

enum edm::Worker::State

Enumerator
Ready
Pass
Fail
Exception

Definition at line 79 of file Worker.h.

{ Ready, Pass, Fail, Exception };

enum edm::Worker::Types

Enumerator
kAnalyzer
kFilter
kProducer
kOutputModule

Definition at line 80 of file Worker.h.

{ kAnalyzer, kFilter, kProducer, kOutputModule};

Constructor & Destructor Documentation

edm::Worker::Worker	(	ModuleDescription const &	iMD,
		ExceptionToActionTable const *	iActions
	)

Definition at line 72 of file Worker.cc.

                                                 :
    timesRun_(0),
    timesVisited_(0),
    timesPassed_(0),
    timesFailed_(0),
    timesExcept_(0),
    state_(Ready),
    numberOfPathsOn_(0),
    numberOfPathsLeftToRun_(0),
    moduleCallingContext_(&iMD),
    actions_(iActions),
    cached_exception_(),
    actReg_(),
    earlyDeleteHelper_(nullptr),
    workStarted_(false)
  {
  }

edm::Worker::~Worker ( )

virtual

Definition at line 91 of file Worker.cc.

                  {
  }

edm::Worker::Worker ( Worker const &  )

delete

Member Function Documentation

ActivityRegistry* edm::Worker::activityRegistry ( )

inlineprotected

Definition at line 214 of file Worker.h.

References edm::exceptionContext(), and benchmark_cfg::fb.

Referenced by edm::WorkerT< T >::implDo().

{ return actReg_.get(); }

void edm::Worker::addedToPath ( )

inline

Definition at line 170 of file Worker.h.

Referenced by edm::WorkerInPath::WorkerInPath().

                       {
      ++numberOfPathsOn_;
    }

void edm::Worker::beginJob

(

void

)

Definition at line 245 of file Worker.cc.

References actReg_, cms::Exception::addContext(), description(), Exception, implBeginJob(), edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), state_, and edm::convertException::wrap().

Referenced by edm::WorkerManager::beginJob(), and edm::GlobalSchedule::replaceModule().

                        {
    try {
      convertException::wrap([&]() {
        ModuleBeginJobSignalSentry cpp(actReg_.get(), description());
        implBeginJob();
      });
    }
    catch(cms::Exception& ex) {
      state_ = Exception;
      std::ostringstream ost;
      ost << "Calling beginJob for module " << description().moduleName() << "/'" << description().moduleLabel() << "'";
      ex.addContext(ost.str());
      throw;
    }
  }

void edm::Worker::beginStream	(	StreamID	id,
		StreamContext &	streamContext
	)

Definition at line 277 of file Worker.cc.

References actReg_, cms::Exception::addContext(), description(), Exception, implBeginStream(), edm::LuminosityBlockIndex::invalidLuminosityBlockIndex(), edm::RunIndex::invalidRunIndex(), edm::StreamContext::kBeginStream, edm::ModuleCallingContext::kRunning, moduleCallingContext_, edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), edm::StreamContext::setEventID(), edm::StreamContext::setLuminosityBlockIndex(), edm::StreamContext::setRunIndex(), edm::ModuleCallingContext::setState(), edm::StreamContext::setTimestamp(), edm::StreamContext::setTransition(), state_, and edm::convertException::wrap().

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

                                                                    {
    try {
      convertException::wrap([&]() {
        streamContext.setTransition(StreamContext::Transition::kBeginStream);
        streamContext.setEventID(EventID(0, 0, 0));
        streamContext.setRunIndex(RunIndex::invalidRunIndex());
        streamContext.setLuminosityBlockIndex(LuminosityBlockIndex::invalidLuminosityBlockIndex());
        streamContext.setTimestamp(Timestamp());
        ParentContext parentContext(&streamContext);
        ModuleContextSentry moduleContextSentry(&moduleCallingContext_, parentContext);
        moduleCallingContext_.setState(ModuleCallingContext::State::kRunning);
        ModuleBeginStreamSignalSentry beginSentry(actReg_.get(), streamContext, moduleCallingContext_);
        implBeginStream(id);
      });
    }
    catch(cms::Exception& ex) {
      state_ = Exception;
      std::ostringstream ost;
      ost << "Calling beginStream for module " << description().moduleName() << "/'" << description().moduleLabel() << "'";
      ex.addContext(ost.str());
      throw;
    }
  }

void edm::Worker::callWhenDoneAsync ( WaitingTask *  task )

inline

Definition at line 115 of file Worker.h.

References bk::beginJob().

                                              {
      waitingTasks_.add(task);
    }

void edm::Worker::clearCounters ( )

inline

Definition at line 162 of file Worker.h.

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

                         {
      timesRun_.store(0,std::memory_order_release);
      timesVisited_.store(0,std::memory_order_release);
      timesPassed_.store(0,std::memory_order_release);
      timesFailed_.store(0,std::memory_order_release);
      timesExcept_.store(0,std::memory_order_release);
    }

virtual std::vector<ConsumesInfo> edm::Worker::consumesInfo ( ) const

pure virtual

Implemented in edm::WorkerT< T >.

Referenced by edm::PathsAndConsumesOfModules::doConsumesInfo().

virtual void edm::Worker::convertCurrentProcessAlias ( std::string const &  processName )

pure virtual

Implemented in edm::WorkerT< T >.

ModuleDescription const* edm::Worker::descPtr ( ) const

inline

Definition at line 139 of file Worker.h.

References modifiedElectrons_cfi::processName, and AlCaHLTBitMon_QueryRunRegistry::string.

{return moduleCallingContext_.moduleDescription(); }

ModuleDescription const& edm::Worker::description ( ) const

inline

Definition at line 138 of file Worker.h.

Referenced by beginJob(), beginStream(), endJob(), endStream(), edm::fillModuleInPathSummary(), edm::StreamSchedule::fillWorkers(), edm::fillWorkerSummaryAux(), edm::WorkerT< T >::resolvePutIndicies(), and shouldRethrowException().

{return *(moduleCallingContext_.moduleDescription());}

template<typename T >

bool edm::Worker::doWork	(	typename T::MyPrincipal const &	ep,
		EventSetup const &	c,
		StreamID	stream,
		ParentContext const &	parentContext,
		typename T::Context const *	context
	)

Definition at line 718 of file Worker.h.

References Fail, edm::ServiceRegistry::instance(), edm::ModuleCallingContext::kInvalid, edm::ModuleCallingContext::kPrefetching, edm::make_empty_waiting_task(), Pass, edm::ServiceRegistry::presentToken(), mps_fire::queue, Ready, and edm::ModuleCallingContext::setContext().

Referenced by edm::WorkerInPath::runWorker().

                                                        {

    if (T::isEvent_) {
      timesVisited_.fetch_add(1,std::memory_order_relaxed);
    }
    bool rc = false;

    switch(state_) {
      case Ready: break;
      case Pass: return true;
      case Fail: return false;
      case Exception: {
        std::rethrow_exception(cached_exception_);
      }
    }
    
    bool expected = false;
    if(not workStarted_.compare_exchange_strong(expected, true) ) {
      //another thread beat us here
      auto waitTask = edm::make_empty_waiting_task();
      waitTask->increment_ref_count();
      
      waitingTasks_.add(waitTask.get());
      
      waitTask->wait_for_all();
      
      switch(state_) {
        case Ready: assert(false);
        case Pass: return true;
        case Fail: return false;
        case Exception: {
          std::rethrow_exception(cached_exception_);
        }
      }
    }

    //Need the context to be set until after any exception is resolved
    moduleCallingContext_.setContext(ModuleCallingContext::State::kPrefetching,parentContext,nullptr);

    auto resetContext = [](ModuleCallingContext* iContext) {iContext->setContext(ModuleCallingContext::State::kInvalid,ParentContext(),nullptr); };
    std::unique_ptr<ModuleCallingContext, decltype(resetContext)> prefetchSentry(&moduleCallingContext_,resetContext);

    if (T::isEvent_) {
      try {
        //if have TriggerResults based selection we want to reject the event before doing prefetching
        if( not workerhelper::CallImpl<T>::prePrefetchSelection(this,streamID,ep,&moduleCallingContext_) ) {
          timesRun_.fetch_add(1,std::memory_order_relaxed);
          rc = setPassed<T::isEvent_>();
          waitingTasks_.doneWaiting(nullptr);
          return true;
        }
      }catch(...) {}
      auto waitTask = edm::make_empty_waiting_task();
      {
        //Make sure signal is sent once the prefetching is done
        // [the 'pre' signal was sent in prefetchAsync]
        //The purpose of this block is to send the signal after wait_for_all
        auto sentryFunc = [this](void*) {
          emitPostModuleEventPrefetchingSignal();
        };
        std::unique_ptr<ActivityRegistry, decltype(sentryFunc)> signalSentry(actReg_.get(),sentryFunc);
        
        //set count to 2 since wait_for_all requires value to not go to 0
        waitTask->set_ref_count(2);
        
        prefetchAsync(waitTask.get(),parentContext, ep);
        waitTask->decrement_ref_count();
        waitTask->wait_for_all();
      }
      if(waitTask->exceptionPtr() != nullptr) {
        TransitionIDValue<typename T::MyPrincipal> idValue(ep);
        if(shouldRethrowException(*waitTask->exceptionPtr(), parentContext, T::isEvent_, idValue)) {
          setException<T::isEvent_>(*waitTask->exceptionPtr());
          waitingTasks_.doneWaiting(cached_exception_);
          std::rethrow_exception(cached_exception_);
        } else {
          setPassed<T::isEvent_>();
          waitingTasks_.doneWaiting(nullptr);
          return true;
        }
      }
    }
    
    //successful prefetch so no reset necessary
    prefetchSentry.release();
    if(auto queue = serializeRunModule()) {
      auto serviceToken = ServiceRegistry::instance().presentToken();
      queue->pushAndWait([&]() {
        //Need to make the services available
        ServiceRegistry::Operate guard(serviceToken);
        try {
          rc = runModule<T>(ep,es,streamID,parentContext,context);
        } catch(...) {
        }
      });
    } else {
      try {
        rc = runModule<T>(ep,es,streamID,parentContext,context);
      } catch(...) {
      }
    }
    if(state_ == Exception) {
      waitingTasks_.doneWaiting(cached_exception_);
      std::rethrow_exception(cached_exception_);
    }
    
    waitingTasks_.doneWaiting(nullptr);
    return rc;
  }

template<typename T >

void edm::Worker::doWorkAsync	(	WaitingTask *	task,
		typename T::MyPrincipal const &	ep,
		EventSetup const &	c,
		StreamID	stream,
		ParentContext const &	parentContext,
		typename T::Context const *	context
	)

Definition at line 620 of file Worker.h.

References edm::ModuleCallingContext::kPrefetching, and edm::ModuleCallingContext::setContext().

Referenced by edm::WorkerInPath::runWorkerAsync().

                                                             {
    waitingTasks_.add(task);
    if(T::isEvent_) {
      timesVisited_.fetch_add(1,std::memory_order_relaxed);
    }

    bool expected = false;
    if(workStarted_.compare_exchange_strong(expected,true)) {
      moduleCallingContext_.setContext(ModuleCallingContext::State::kPrefetching,parentContext,nullptr);

      //if have TriggerResults based selection we want to reject the event before doing prefetching
      try {
        if( not workerhelper::CallImpl<T>::prePrefetchSelection(this,streamID,ep,&moduleCallingContext_) ) {
          setPassed<T::isEvent_>();
          waitingTasks_.doneWaiting(nullptr);
          return;
        }
      }catch(...) {}
      
      auto runTask = new (tbb::task::allocate_root()) RunModuleTask<T>(
        this, ep,es,streamID,parentContext,context);
      prefetchAsync(runTask, parentContext, ep);
    }
  }

template<typename T >

void edm::Worker::doWorkNoPrefetchingAsync	(	WaitingTask *	task,
		typename T::MyPrincipal const &	principal,
		EventSetup const &	c,
		StreamID	stream,
		ParentContext const &	parentContext,
		typename T::Context const *	context
	)

Definition at line 680 of file Worker.h.

References edm::ServiceRegistry::instance(), edm::make_functor_task(), edm::ServiceRegistry::presentToken(), cmsRelvalreport::principal(), and mps_fire::queue.

Referenced by edm::WorkerInPath::runWorkerAsync().

                                                             {
    waitingTasks_.add(task);
    bool expected = false;
    if(workStarted_.compare_exchange_strong(expected,true)) {
      auto serviceToken = ServiceRegistry::instance().presentToken();
      
      auto toDo =[this, &principal, &es, streamID,parentContext,context, serviceToken]()
      {
        std::exception_ptr exceptionPtr;
        try {
          //Need to make the services available
          ServiceRegistry::Operate guard(serviceToken);
            
          this->runModule<T>(principal,
                               es,
                               streamID,
                               parentContext,
                               context);
        } catch( ... ) {
          exceptionPtr = std::current_exception();
        }
        this->waitingTasks_.doneWaiting(exceptionPtr);
      };
      if(auto queue = this->serializeRunModule()) {
        queue->push( toDo);
      } else {
        auto task = make_functor_task( tbb::task::allocate_root(), toDo);
        tbb::task::spawn(*task);
      }
    }
  }

void edm::Worker::emitPostModuleEventPrefetchingSignal ( )

inlineprivate

Definition at line 306 of file Worker.h.

                                                {
      actReg_->postModuleEventPrefetchingSignal_.emit(*moduleCallingContext_.getStreamContext(),moduleCallingContext_);
    }

void edm::Worker::endJob

(

void

)

Definition at line 261 of file Worker.cc.

References actReg_, cms::Exception::addContext(), description(), Exception, implEndJob(), edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), state_, and edm::convertException::wrap().

                      {
    try {
      convertException::wrap([&]() {
        ModuleEndJobSignalSentry cpp(actReg_.get(), description());
        implEndJob();
      });
    }
    catch(cms::Exception& ex) {
      state_ = Exception;
      std::ostringstream ost;
      ost << "Calling endJob for module " << description().moduleName() << "/'" << description().moduleLabel() << "'";
      ex.addContext(ost.str());
      throw;
    }
  }

void edm::Worker::endStream	(	StreamID	id,
		StreamContext &	streamContext
	)

Definition at line 301 of file Worker.cc.

References actReg_, cms::Exception::addContext(), description(), Exception, implEndStream(), edm::LuminosityBlockIndex::invalidLuminosityBlockIndex(), edm::RunIndex::invalidRunIndex(), edm::StreamContext::kEndStream, edm::ModuleCallingContext::kRunning, moduleCallingContext_, edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), edm::StreamContext::setEventID(), edm::StreamContext::setLuminosityBlockIndex(), edm::StreamContext::setRunIndex(), edm::ModuleCallingContext::setState(), edm::StreamContext::setTimestamp(), edm::StreamContext::setTransition(), state_, and edm::convertException::wrap().

                                                                  {
    try {
      convertException::wrap([&]() {
        streamContext.setTransition(StreamContext::Transition::kEndStream);
        streamContext.setEventID(EventID(0, 0, 0));
        streamContext.setRunIndex(RunIndex::invalidRunIndex());
        streamContext.setLuminosityBlockIndex(LuminosityBlockIndex::invalidLuminosityBlockIndex());
        streamContext.setTimestamp(Timestamp());
        ParentContext parentContext(&streamContext);
        ModuleContextSentry moduleContextSentry(&moduleCallingContext_, parentContext);
        moduleCallingContext_.setState(ModuleCallingContext::State::kRunning);
        ModuleEndStreamSignalSentry endSentry(actReg_.get(), streamContext, moduleCallingContext_);
        implEndStream(id);
      });
    }
    catch(cms::Exception& ex) {
      state_ = Exception;
      std::ostringstream ost;
      ost << "Calling endStream for module " << description().moduleName() << "/'" << description().moduleLabel() << "'";
      ex.addContext(ost.str());
      throw;
    }
  }

void edm::Worker::exceptionContext ( cms::Exception &  ex, ModuleCallingContext const *  mcc  )

staticprivate

Definition at line 99 of file Worker.cc.

References cms::Exception::addContext(), edm::exceptionContext(), edm::ModuleCallingContext::globalContext(), edm::ModuleCallingContext::internalContext(), edm::ParentContext::kGlobal, edm::ParentContext::kInternal, edm::ParentContext::kModule, edm::ParentContext::kPlaceInPath, edm::ModuleCallingContext::kPrefetching, edm::ParentContext::kStream, edm::InternalContext::moduleCallingContext(), edm::ModuleCallingContext::moduleCallingContext(), edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), or, edm::PlaceInPathContext::pathContext(), edm::PathContext::pathName(), edm::ModuleCallingContext::placeInPathContext(), edm::ModuleCallingContext::state(), edm::PathContext::streamContext(), edm::ModuleCallingContext::streamContext(), and edm::ModuleCallingContext::type().

                                                         {
    
    ModuleCallingContext const* imcc = mcc;
    while( (imcc->type() == ParentContext::Type::kModule) or
          (imcc->type()  == ParentContext::Type::kInternal) ) {
      std::ostringstream iost;
      if( imcc->state() == ModuleCallingContext::State::kPrefetching ) {
        iost << "Prefetching for module ";
      } else {
        iost << "Calling method for module ";
      }
      iost << imcc->moduleDescription()->moduleName() << "/'"
      << imcc->moduleDescription()->moduleLabel() << "'";

      if(imcc->type() == ParentContext::Type::kInternal) {
        iost << " (probably inside some kind of mixing module)";
        imcc = imcc->internalContext()->moduleCallingContext();
      } else {
        imcc = imcc->moduleCallingContext();
      }
      ex.addContext(iost.str());
    }
    std::ostringstream ost;
    if( imcc->state() == ModuleCallingContext::State::kPrefetching ) {
      ost << "Prefetching for module ";
    } else {
      ost << "Calling method for module ";
    }
    ost << imcc->moduleDescription()->moduleName() << "/'"
    << imcc->moduleDescription()->moduleLabel() << "'";
    ex.addContext(ost.str());
    
    if (imcc->type() == ParentContext::Type::kPlaceInPath) {
      ost.str("");
      ost << "Running path '";
      ost << imcc->placeInPathContext()->pathContext()->pathName() << "'";
      ex.addContext(ost.str());
      auto streamContext =imcc->placeInPathContext()->pathContext()->streamContext();
      if(streamContext) {
        ost.str("");
        edm::exceptionContext(ost,*streamContext);
        ex.addContext(ost.str());
      }
    } else {
      if (imcc->type() == ParentContext::Type::kStream) {
        ost.str("");
        edm::exceptionContext(ost, *(imcc->streamContext()) );
        ex.addContext(ost.str());
      } else if(imcc->type() == ParentContext::Type::kGlobal) {
        ost.str("");
        edm::exceptionContext(ost, *(imcc->globalContext()) );
        ex.addContext(ost.str());
      }
    }
  }

virtual void edm::Worker::implBeginJob ( )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by beginJob().

virtual void edm::Worker::implBeginStream ( StreamID  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by beginStream().

virtual bool edm::Worker::implDo ( EventPrincipal const &  , EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by edm::workerhelper::CallImpl< OccurrenceTraits< EventPrincipal, BranchActionStreamBegin > >::call().

virtual bool edm::Worker::implDoBegin ( RunPrincipal const &  rp, EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by edm::workerhelper::CallImpl< OccurrenceTraits< RunPrincipal, BranchActionGlobalBegin > >::call(), and edm::workerhelper::CallImpl< OccurrenceTraits< LuminosityBlockPrincipal, BranchActionGlobalBegin > >::call().

virtual bool edm::Worker::implDoBegin ( LuminosityBlockPrincipal const &  lbp, EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

virtual bool edm::Worker::implDoEnd ( RunPrincipal const &  rp, EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by edm::workerhelper::CallImpl< OccurrenceTraits< RunPrincipal, BranchActionGlobalEnd > >::call(), and edm::workerhelper::CallImpl< OccurrenceTraits< LuminosityBlockPrincipal, BranchActionGlobalEnd > >::call().

virtual bool edm::Worker::implDoEnd ( LuminosityBlockPrincipal const &  lbp, EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

virtual bool edm::Worker::implDoPrePrefetchSelection ( StreamID  id, EventPrincipal const &  ep, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, and edm::WorkerT< T >.

Referenced by edm::workerhelper::CallImpl< OccurrenceTraits< EventPrincipal, BranchActionStreamBegin > >::prePrefetchSelection().

virtual bool edm::Worker::implDoStreamBegin ( StreamID  id, RunPrincipal const &  rp, EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by edm::workerhelper::CallImpl< OccurrenceTraits< RunPrincipal, BranchActionStreamBegin > >::call(), and edm::workerhelper::CallImpl< OccurrenceTraits< LuminosityBlockPrincipal, BranchActionStreamBegin > >::call().

virtual bool edm::Worker::implDoStreamBegin ( StreamID  id, LuminosityBlockPrincipal const &  lbp, EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

virtual bool edm::Worker::implDoStreamEnd ( StreamID  id, RunPrincipal const &  rp, EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by edm::workerhelper::CallImpl< OccurrenceTraits< RunPrincipal, BranchActionStreamEnd > >::call(), and edm::workerhelper::CallImpl< OccurrenceTraits< LuminosityBlockPrincipal, BranchActionStreamEnd > >::call().

virtual bool edm::Worker::implDoStreamEnd ( StreamID  id, LuminosityBlockPrincipal const &  lbp, EventSetup const &  c, ModuleCallingContext const *  mcc  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

virtual void edm::Worker::implEndJob ( )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by endJob().

virtual void edm::Worker::implEndStream ( StreamID  )

protectedpure virtual

Implemented in edm::WorkerT< T >.

Referenced by endStream().

virtual void edm::Worker::implRegisterThinnedAssociations ( ProductRegistry const &  , ThinnedAssociationsHelper &    )

privatepure virtual

Implemented in edm::WorkerT< T >.

virtual void edm::Worker::implRespondToCloseInputFile ( FileBlock const &  fb )

privatepure virtual

Implemented in edm::WorkerT< T >.

virtual void edm::Worker::implRespondToOpenInputFile ( FileBlock const &  fb )

privatepure virtual

Implemented in edm::WorkerT< T >.

virtual void edm::Worker::itemsMayGet ( BranchType  , std::vector< ProductResolverIndexAndSkipBit > &    ) const

privatepure virtual

Implemented in edm::WorkerT< T >.

virtual std::vector<ProductResolverIndex> const& edm::Worker::itemsShouldPutInEvent ( ) const

privatepure virtual

Implemented in edm::WorkerT< T >.

virtual void edm::Worker::itemsToGet ( BranchType  , std::vector< ProductResolverIndexAndSkipBit > &    ) const

privatepure virtual

Implemented in edm::WorkerT< T >.

virtual std::vector<ProductResolverIndexAndSkipBit> const& edm::Worker::itemsToGetFrom ( BranchType  ) const

privatepure virtual

Implemented in edm::WorkerT< T >.

Referenced by prefetchAsync().

virtual void edm::Worker::modulesWhoseProductsAreConsumed ( std::vector< ModuleDescription const * > &  modules, ProductRegistry const &  preg, std::map< std::string, ModuleDescription const * > const &  labelsToDesc  ) const

pure virtual

Implemented in edm::WorkerT< T >.

virtual Types edm::Worker::moduleType ( ) const

pure virtual

Implemented in edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, and edm::WorkerT< T >.

Referenced by edm::WorkerManager::addToUnscheduledWorkers(), and edm::StreamSchedule::fillWorkers().

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

delete

Referenced by edm::stream::EDFilterAdaptorBase::workerType(), and edm::stream::EDProducerAdaptorBase::workerType().

void edm::Worker::postDoEvent

(

EventPrincipal const &

iEvent

)

Definition at line 331 of file Worker.cc.

References earlyDeleteHelper_.

Referenced by edm::WorkerT< T >::implDo().

                                                       {
    if(earlyDeleteHelper_) {
      earlyDeleteHelper_->moduleRan(iEvent);
    }
  }

virtual void edm::Worker::preActionBeforeRunEventAsync ( WaitingTask *  iTask, ModuleCallingContext const &  moduleCallingContext, Principal const &  iPrincipal  ) const

privatepure virtual

Implemented in edm::WorkerT< T >.

Referenced by prefetchAsync().

void edm::Worker::prefetchAsync ( WaitingTask *  iTask, ParentContext const &  parentContext, Principal const &  iPrincipal  )

private

Definition at line 205 of file Worker.cc.

References actReg_, edm::Principal::branchType(), edm::ModuleCallingContext::getStreamContext(), edm::InEvent, mps_monitormerge::items, itemsToGetFrom(), edm::ModuleCallingContext::kPrefetching, moduleCallingContext_, preActionBeforeRunEventAsync(), edm::Principal::prefetchAsync(), edm::ProductResolverIndexAmbiguous, and edm::ModuleCallingContext::setContext().

                                                                                                                {
    // Prefetch products the module declares it consumes (not including the products it maybe consumes)
    std::vector<ProductResolverIndexAndSkipBit> const& items = itemsToGetFrom(iPrincipal.branchType());

    moduleCallingContext_.setContext(ModuleCallingContext::State::kPrefetching,parentContext,nullptr);
    
    if(iPrincipal.branchType()==InEvent) {
      actReg_->preModuleEventPrefetchingSignal_.emit(*moduleCallingContext_.getStreamContext(),moduleCallingContext_);
    }

    //Need to be sure the ref count isn't set to 0 immediately
    iTask->increment_ref_count();
    for(auto const& item : items) {
      ProductResolverIndex productResolverIndex = item.productResolverIndex();
      bool skipCurrentProcess = item.skipCurrentProcess();
      if(productResolverIndex != ProductResolverIndexAmbiguous) {
        iPrincipal.prefetchAsync(iTask,productResolverIndex, skipCurrentProcess, &moduleCallingContext_);
      }
    }
    
    if(iPrincipal.branchType()==InEvent) {
      preActionBeforeRunEventAsync(iTask,moduleCallingContext_,iPrincipal);
    }
    
    if(0 == iTask->decrement_ref_count()) {
      //if everything finishes before we leave this routine, we need to launch the task
      tbb::task::spawn(*iTask);
    }
  }

void edm::Worker::registerThinnedAssociations ( ProductRegistry const &  registry, ThinnedAssociationsHelper &  helper  )

inline

Definition at line 126 of file Worker.h.

{ implRegisterThinnedAssociations(registry, helper); }

void edm::Worker::reset ( void  )

inline

Definition at line 128 of file Worker.h.

References Ready.

Referenced by edm::WorkerManager::resetAll().

                 {
      cached_exception_ = std::exception_ptr();
      state_ = Ready;
      waitingTasks_.reset();
      workStarted_ = false;
      numberOfPathsLeftToRun_ = numberOfPathsOn_;
    }

void edm::Worker::resetModuleDescription ( ModuleDescription const *  iDesc )

protected

Definition at line 239 of file Worker.cc.

References moduleCallingContext_, edm::ModuleCallingContext::parent(), edm::ModuleCallingContext::previousModuleOnThread(), edm::ModuleCallingContext::state(), and groupFilesInBlocks::temp.

Referenced by edm::WorkerT< T >::setModule().

                                                                    {
    ModuleCallingContext temp(iDesc,moduleCallingContext_.state(),moduleCallingContext_.parent(),
                              moduleCallingContext_.previousModuleOnThread());
    moduleCallingContext_ = temp;
  }

virtual void edm::Worker::resolvePutIndicies ( BranchType  iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &  iIndicies  )

pure virtual

Implemented in edm::WorkerT< T >.

void edm::Worker::respondToCloseInputFile ( FileBlock const &  fb )

inline

Definition at line 124 of file Worker.h.

Referenced by edm::Schedule::respondToCloseInputFile().

{implRespondToCloseInputFile(fb);}

void edm::Worker::respondToOpenInputFile ( FileBlock const &  fb )

inline

Definition at line 123 of file Worker.h.

Referenced by edm::Schedule::respondToOpenInputFile().

{implRespondToOpenInputFile(fb);}

template<typename T >

bool edm::Worker::runModule ( typename T::MyPrincipal const &  ep, EventSetup const &  c, StreamID  stream, ParentContext const &  parentContext, typename T::Context const *  context  )

private

Definition at line 834 of file Worker.h.

References edm::exceptionContext(), edm::EventSetup::get(), and edm::convertException::wrap().

                                                        {
    //unscheduled producers should advance this
    //if (T::isEvent_) {
    //  ++timesVisited_;
    //}
    ModuleContextSentry moduleContextSentry(&moduleCallingContext_, parentContext);
    if (T::isEvent_) {
      timesRun_.fetch_add(1,std::memory_order_relaxed);
    }

    bool rc = true;
    try {
      convertException::wrap([&]()
      {
        rc = workerhelper::CallImpl<T>::call(this,streamID,ep,es, actReg_.get(), &moduleCallingContext_, context);
        
        if (rc) {
          setPassed<T::isEvent_>();
        } else {
          setFailed<T::isEvent_>();
        }
      });
    } catch(cms::Exception& ex) {
      exceptionContext(ex, &moduleCallingContext_);
      TransitionIDValue<typename T::MyPrincipal> idValue(ep);
      if(shouldRethrowException(std::current_exception(), parentContext, T::isEvent_, idValue)) {
        assert(not cached_exception_);
        setException<T::isEvent_>(std::current_exception());
        std::rethrow_exception(cached_exception_);
      } else {
        rc = setPassed<T::isEvent_>();
      }
    }
    
    return rc;
  }

template<typename T >

std::exception_ptr edm::Worker::runModuleAfterAsyncPrefetch ( std::exception_ptr const *  iEPtr, typename T::MyPrincipal const &  ep, EventSetup const &  es, StreamID  streamID, ParentContext const &  parentContext, typename T::Context const *  context  )

private

Definition at line 651 of file Worker.h.

References edm::ModuleCallingContext::kInvalid, and edm::ModuleCallingContext::setContext().

Referenced by edm::Worker::RunModuleTask< T >::execute().

                                                                                           {
    std::exception_ptr exceptionPtr;
    if(iEPtr) {
      assert(*iEPtr);
      TransitionIDValue<typename T::MyPrincipal> idValue(ep);
      if(shouldRethrowException(*iEPtr, parentContext, T::isEvent_, idValue)) {
        exceptionPtr = *iEPtr;
        setException<T::isEvent_>(exceptionPtr);
      } else {
        setPassed<T::isEvent_>();
      }
      moduleCallingContext_.setContext(ModuleCallingContext::State::kInvalid,ParentContext(),nullptr);
    } else {
      try {
        runModule<T>(ep,es,streamID,parentContext,context);
      } catch(...) {
        exceptionPtr = std::current_exception();
      }
    }
    waitingTasks_.doneWaiting(exceptionPtr);
    return exceptionPtr;
  }

template<typename T >

std::exception_ptr edm::Worker::runModuleDirectly	(	typename T::MyPrincipal const &	ep,
		EventSetup const &	es,
		StreamID	streamID,
		ParentContext const &	parentContext,
		typename T::Context const *	context
	)

Definition at line 876 of file Worker.h.

Referenced by edm::Path::finished().

                                                                                 {

    timesVisited_.fetch_add(1,std::memory_order_relaxed);
    std::exception_ptr const* prefetchingException = nullptr; // null because there was no prefetching to do
    return runModuleAfterAsyncPrefetch<T>(prefetchingException, ep, es, streamID, parentContext, context);
  }

virtual SerialTaskQueueChain* edm::Worker::serializeRunModule ( )

privatepure virtual

Implemented in edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, edm::WorkerT< T >, and edm::WorkerT< T >.

void edm::Worker::setActivityRegistry

(

std::shared_ptr< ActivityRegistry >

areg

)

The signals are required to live longer than the last call to 'doWork' this was done to improve performance based on profiling

Definition at line 94 of file Worker.cc.

References actReg_.

                                                                       {
    actReg_ = areg;
  }

void edm::Worker::setEarlyDeleteHelper

(

EarlyDeleteHelper *

iHelper

)

Definition at line 235 of file Worker.cc.

References earlyDeleteHelper_.

                                                              {
    earlyDeleteHelper_=iHelper;
  }

template<bool IS_EVENT>

std::exception_ptr edm::Worker::setException ( std::exception_ptr  iException )

inlineprivate

Definition at line 293 of file Worker.h.

References Exception.

                                                               {
      if (IS_EVENT) {
        timesExcept_.fetch_add(1,std::memory_order_relaxed);
      }
      cached_exception_ = iException; // propagate_const<T> has no reset() function
      state_ = Exception;
      return cached_exception_;
    }

template<bool IS_EVENT>

bool edm::Worker::setFailed ( )

inlineprivate

Definition at line 284 of file Worker.h.

References Fail.

                     {
      if(IS_EVENT) {
        timesFailed_.fetch_add(1,std::memory_order_relaxed);
      }
      state_ = Fail;
      return false;
    }

template<bool IS_EVENT>

bool edm::Worker::setPassed ( )

inlineprivate

Definition at line 275 of file Worker.h.

References Pass.

                     {
      if(IS_EVENT) {
        timesPassed_.fetch_add(1,std::memory_order_relaxed);
      }
      state_ = Pass;
      return true;
    }

bool edm::Worker::shouldRethrowException ( std::exception_ptr  iPtr, ParentContext const &  parentContext, bool  isEvent, TransitionIDValueBase const &  iID  ) const

private

Definition at line 157 of file Worker.cc.

References mps_alisetup::action, actions_, cms::Exception::category(), description(), edm::exception_actions::FailPath, edm::ExceptionToActionTable::find(), edm::ModuleCallingContext::getTopModuleCallingContext(), edm::exception_actions::IgnoreCompletely, edm::PathContext::isEndPath(), edm::ModuleCallingContext::kInvalid, edm::ParentContext::kPlaceInPath, edm::PlaceInPathContext::pathContext(), edm::ModuleCallingContext::placeInPathContext(), edm::printCmsExceptionWarning(), edm::exception_actions::Rethrow, edm::exception_actions::SkipEvent, edm::ModuleCallingContext::type(), and edm::convertException::wrap().

                                                                              {
    
    // NOTE: the warning printed as a result of ignoring or failing
    // a module will only be printed during the full true processing
    // pass of this module
    
    // Get the action corresponding to this exception.  However, if processing
    // something other than an event (e.g. run, lumi) always rethrow.
    if(not isEvent) {
      return true;
    }
    try {
      convertException::wrap([&]() {
        std::rethrow_exception(iPtr);
      });
    } catch(cms::Exception &ex) {
      exception_actions::ActionCodes action = actions_->find(ex.category());
    
      if(action == exception_actions::Rethrow) {
        return true;
      }
    
      ModuleCallingContext tempContext(&description(),ModuleCallingContext::State::kInvalid, parentContext, nullptr);
      
      // If we are processing an endpath and the module was scheduled, treat SkipEvent or FailPath
      // as IgnoreCompletely, so any subsequent OutputModules are still run.
      // For unscheduled modules only treat FailPath as IgnoreCompletely but still allow SkipEvent to throw
      ModuleCallingContext const* top_mcc = tempContext.getTopModuleCallingContext();
      if(top_mcc->type() == ParentContext::Type::kPlaceInPath &&
         top_mcc->placeInPathContext()->pathContext()->isEndPath()) {
        
        if ((action == exception_actions::SkipEvent && tempContext.type() == ParentContext::Type::kPlaceInPath) ||
            action == exception_actions::FailPath) {
          action = exception_actions::IgnoreCompletely;
        }
      }
      if(action == exception_actions::IgnoreCompletely) {
        edm::printCmsExceptionWarning("IgnoreCompletely", ex);
        return false;
      }
    }
    return true;
  }

void edm::Worker::skipOnPath

(

)

Definition at line 325 of file Worker.cc.

References cached_exception_, edm::WaitingTaskList::doneWaiting(), numberOfPathsLeftToRun_, and waitingTasks_.

Referenced by edm::WorkerInPath::skipWorker().

                          {
    if( 0 == --numberOfPathsLeftToRun_) {
      waitingTasks_.doneWaiting(cached_exception_);
    }
  }

State edm::Worker::state ( ) const

inline

Definition at line 179 of file Worker.h.

Referenced by edm::WorkerInPath::checkResultsOfRunWorker().

{ return state_; }

int edm::Worker::timesExcept ( ) const

inline

Definition at line 178 of file Worker.h.

Referenced by edm::fillWorkerSummaryAux().

{ return timesExcept_.load(std::memory_order_acquire); }

int edm::Worker::timesFailed ( ) const

inline

Definition at line 177 of file Worker.h.

Referenced by edm::fillWorkerSummaryAux().

{ return timesFailed_.load(std::memory_order_acquire); }

int edm::Worker::timesPass ( ) const

inline

Definition at line 181 of file Worker.h.

{ return timesPassed(); } // for backward compatibility only - to be removed soon

int edm::Worker::timesPassed ( ) const

inline

Definition at line 176 of file Worker.h.

Referenced by edm::fillWorkerSummaryAux().

{ return timesPassed_.load(std::memory_order_acquire); }

int edm::Worker::timesRun ( ) const

inline

Definition at line 174 of file Worker.h.

Referenced by edm::fillWorkerSummaryAux().

{ return timesRun_.load(std::memory_order_acquire); }

int edm::Worker::timesVisited ( ) const

inline

Definition at line 175 of file Worker.h.

Referenced by edm::fillWorkerSummaryAux().

{ return timesVisited_.load(std::memory_order_acquire); }

virtual void edm::Worker::updateLookup ( BranchType  iBranchType, ProductResolverIndexHelper const &    )

pure virtual

Implemented in edm::WorkerT< T >.

Referenced by edm::Schedule::changeModule().

virtual std::string edm::Worker::workerType ( ) const

protectedpure virtual

Implemented in edm::WorkerT< T >.

Friends And Related Function Documentation

template<typename O >

friend class workerhelper::CallImpl

friend

Definition at line 184 of file Worker.h.

Member Data Documentation

ExceptionToActionTable const* edm::Worker::actions_

private

Definition at line 411 of file Worker.h.

Referenced by shouldRethrowException().

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

private

Definition at line 414 of file Worker.h.

Referenced by beginJob(), beginStream(), endJob(), endStream(), prefetchAsync(), and setActivityRegistry().

std::exception_ptr edm::Worker::cached_exception_

private

Definition at line 412 of file Worker.h.

Referenced by skipOnPath().

edm::propagate_const<EarlyDeleteHelper*> edm::Worker::earlyDeleteHelper_

private

Definition at line 416 of file Worker.h.

Referenced by postDoEvent(), and setEarlyDeleteHelper().

ModuleCallingContext edm::Worker::moduleCallingContext_

private

Definition at line 409 of file Worker.h.

Referenced by beginStream(), endStream(), prefetchAsync(), and resetModuleDescription().

std::atomic<int> edm::Worker::numberOfPathsLeftToRun_

private

Definition at line 407 of file Worker.h.

Referenced by skipOnPath().

int edm::Worker::numberOfPathsOn_

private

Definition at line 406 of file Worker.h.

std::atomic<State> edm::Worker::state_

private

Definition at line 405 of file Worker.h.

Referenced by beginJob(), beginStream(), endJob(), and endStream().

std::atomic<int> edm::Worker::timesExcept_

private

Definition at line 404 of file Worker.h.

std::atomic<int> edm::Worker::timesFailed_

private

Definition at line 403 of file Worker.h.

std::atomic<int> edm::Worker::timesPassed_

private

Definition at line 402 of file Worker.h.

std::atomic<int> edm::Worker::timesRun_

private

Definition at line 400 of file Worker.h.

std::atomic<int> edm::Worker::timesVisited_

private

Definition at line 401 of file Worker.h.

edm::WaitingTaskList edm::Worker::waitingTasks_

private

Definition at line 418 of file Worker.h.

Referenced by skipOnPath().

std::atomic<bool> edm::Worker::workStarted_

private

Definition at line 419 of file Worker.h.