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
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)
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	postForkReacquireResources (unsigned int iChildIndex, unsigned int iNumberOfChildren)
void	preForkReleaseResources ()
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)
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	implPostForkReacquireResources (unsigned int iChildIndex, unsigned int iNumberOfChildren)=0
virtual void	implPreForkReleaseResources ()=0
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 &	itemsToGetFromEvent () 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 >
void	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 (cms::Exception &ex, ParentContext const &parentContext, bool isEvent, TransitionIDValueBase const &iID) const

Static Private Member Functions
static void	exceptionContext (const std::string &iID, bool iIsEvent, 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 75 of file Worker.h.

Member Enumeration Documentation

enum edm::Worker::State

Enumerator
Ready
Pass
Fail
Exception

Definition at line 77 of file Worker.h.

{ Ready, Pass, Fail, Exception };

enum edm::Worker::Types

Enumerator
kAnalyzer
kFilter
kProducer
kOutputModule

Definition at line 78 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_(),
    timesVisited_(),
    timesPassed_(),
    timesFailed_(),
    timesExcept_(),
    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 197 of file Worker.h.

References actReg_.

{ return actReg_.get(); }

void edm::Worker::addedToPath ( )

inline

Definition at line 153 of file Worker.h.

References numberOfPathsOn_.

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

                       {
      ++numberOfPathsOn_;
    }

void edm::Worker::beginJob

(

void

)

Definition at line 231 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 263 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 98 of file Worker.h.

References edm::WaitingTaskList::add(), and waitingTasks_.

Referenced by edm::PuttableProductResolver::prefetchAsync_().

                                              {
      waitingTasks_.add(task);
    }

void edm::Worker::clearCounters ( )

inline

Definition at line 145 of file Worker.h.

References timesExcept_, timesFailed_, timesPassed_, timesRun_, and timesVisited_.

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

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

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

pure virtual

Implemented in edm::WorkerT< T >.

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

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

inline

Definition at line 124 of file Worker.h.

References moduleCallingContext_, and edm::ModuleCallingContext::moduleDescription().

{return moduleCallingContext_.moduleDescription(); }

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

inline

Definition at line 123 of file Worker.h.

References moduleCallingContext_, and edm::ModuleCallingContext::moduleDescription().

Referenced by beginJob(), beginStream(), endJob(), endStream(), edm::fillModuleInPathSummary(), edm::StreamSchedule::fillWorkers(), edm::fillWorkerSummaryAux(), runModuleAfterAsyncPrefetch(), 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 671 of file Worker.h.

References actReg_, edm::WaitingTaskList::add(), assert(), cached_exception_, edm::WaitingTaskList::doneWaiting(), emitPostModuleEventPrefetchingSignal(), Fail, edm::ServiceRegistry::instance(), edm::ModuleCallingContext::kInvalid, edm::ModuleCallingContext::kPrefetching, edm::make_empty_waiting_task(), moduleCallingContext_, Pass, prefetchAsync(), edm::ServiceRegistry::presentToken(), mps_fire::queue, Ready, serializeRunModule(), edm::ModuleCallingContext::setContext(), shouldRethrowException(), state_, timesRun_, timesVisited_, waitingTasks_, workStarted_, and edm::convertException::wrap().

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);
    
    try {
      convertException::wrap([&]() {

        if (T::isEvent_) {

          //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;
          }
          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) {
            std::rethrow_exception(*(waitTask->exceptionPtr()));
          }
        }
        //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);
            rc = runModule<T>(ep,es,streamID,parentContext,context);
          });
        } else {
          rc = runModule<T>(ep,es,streamID,parentContext,context);
        }
      });
    }
    catch(cms::Exception& ex) {
      TransitionIDValue<typename T::MyPrincipal> idValue(ep);
      if(shouldRethrowException(ex, parentContext, T::isEvent_, idValue)) {
        assert(not cached_exception_);
        setException<T::isEvent_>(std::current_exception());
        waitingTasks_.doneWaiting(cached_exception_);
        std::rethrow_exception(cached_exception_);
      } else {
        rc = setPassed<T::isEvent_>();
      }
    }
    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 602 of file Worker.h.

References edm::WaitingTaskList::add(), edm::WaitingTaskList::doneWaiting(), edm::ModuleCallingContext::kPrefetching, moduleCallingContext_, prefetchAsync(), edm::ModuleCallingContext::setContext(), timesVisited_, waitingTasks_, and workStarted_.

Referenced by edm::UnscheduledProductResolver::prefetchAsync_(), and 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
      if( not workerhelper::CallImpl<T>::prePrefetchSelection(this,streamID,ep,&moduleCallingContext_) ) {
        setPassed<T::isEvent_>();
        waitingTasks_.doneWaiting(nullptr);
        return;
      }
      
      auto runTask = new (tbb::task::allocate_root()) RunModuleTask<T>(
        this, ep,es,streamID,parentContext,context);
      prefetchAsync(runTask, parentContext, ep);
    }
  }

void edm::Worker::emitPostModuleEventPrefetchingSignal ( )

inlineprivate

Definition at line 290 of file Worker.h.

References actReg_, edm::ModuleCallingContext::getStreamContext(), and moduleCallingContext_.

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

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

void edm::Worker::endJob

(

void

)

Definition at line 247 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 287 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 ( const std::string &  iID, bool  iIsEvent, cms::Exception &  ex, ModuleCallingContext const *  mcc  )

staticprivate

Definition at line 99 of file Worker.cc.

References cms::Exception::addContext(), edm::ModuleCallingContext::internalContext(), edm::ParentContext::kInternal, edm::ParentContext::kModule, edm::ParentContext::kPlaceInPath, edm::InternalContext::moduleCallingContext(), edm::ModuleCallingContext::moduleCallingContext(), edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), edm::PlaceInPathContext::pathContext(), edm::PathContext::pathName(), edm::ModuleCallingContext::placeInPathContext(), and edm::ModuleCallingContext::type().

Referenced by shouldRethrowException().

                                                         {
    
    ModuleCallingContext const* imcc = mcc;
    while(imcc->type() == ParentContext::Type::kModule) {
      std::ostringstream iost;
      iost << "Calling method for module "
      << imcc->moduleDescription()->moduleName() << "/'"
      << imcc->moduleDescription()->moduleLabel() << "'";
      ex.addContext(iost.str());
      imcc = imcc->moduleCallingContext();
    }
    if(imcc->type() == ParentContext::Type::kInternal) {
      std::ostringstream iost;
      iost << "Calling method for module "
      << imcc->moduleDescription()->moduleName() << "/'"
      << imcc->moduleDescription()->moduleLabel() << "' (probably inside some kind of mixing module)";
      ex.addContext(iost.str());
      imcc = imcc->internalContext()->moduleCallingContext();
    }
    while(imcc->type() == ParentContext::Type::kModule) {
      std::ostringstream iost;
      iost << "Calling method for module "
      << imcc->moduleDescription()->moduleName() << "/'"
      << imcc->moduleDescription()->moduleLabel() << "'";
      ex.addContext(iost.str());
      imcc = imcc->moduleCallingContext();
    }
    std::ostringstream ost;
    if (iIsEvent) {
      ost << "Calling event method";
    }
    else {
      // It should be impossible to get here, because
      // this function only gets called when the IgnoreCompletely
      // exception behavior is active, which can only be true
      // for events.
      ost << "Calling unknown function";
    }
    ost << " for module " << 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());
    }
    ost.str("");
    ost << "Processing ";
    ost << iID;
    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::implPostForkReacquireResources ( unsigned int  iChildIndex, unsigned int  iNumberOfChildren  )

privatepure virtual

Implemented in edm::WorkerT< T >.

Referenced by postForkReacquireResources().

virtual void edm::Worker::implPreForkReleaseResources ( )

privatepure virtual

Implemented in edm::WorkerT< T >.

Referenced by preForkReleaseResources().

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

privatepure virtual

Implemented in edm::WorkerT< T >.

Referenced by registerThinnedAssociations().

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

privatepure virtual

Implemented in edm::WorkerT< T >.

Referenced by respondToCloseInputFile().

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

privatepure virtual

Implemented in edm::WorkerT< T >.

Referenced by respondToOpenInputFile().

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::itemsToGetFromEvent ( ) 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

void edm::Worker::postDoEvent

(

EventPrincipal const &

iEvent

)

Definition at line 317 of file Worker.cc.

References earlyDeleteHelper_.

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

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

void edm::Worker::postForkReacquireResources ( unsigned int  iChildIndex, unsigned int  iNumberOfChildren  )

inline

Definition at line 110 of file Worker.h.

References implPostForkReacquireResources().

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

{implPostForkReacquireResources(iChildIndex, iNumberOfChildren);}

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

private

Definition at line 198 of file Worker.cc.

References actReg_, edm::ModuleCallingContext::getStreamContext(), mps_monitormerge::items, itemsToGetFromEvent(), edm::ModuleCallingContext::kPrefetching, moduleCallingContext_, edm::Principal::prefetchAsync(), edm::ProductResolverIndexAmbiguous, and edm::ModuleCallingContext::setContext().

Referenced by doWork(), and doWorkAsync().

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

    moduleCallingContext_.setContext(ModuleCallingContext::State::kPrefetching,parentContext,nullptr);
    
    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(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::preForkReleaseResources ( )

inline

Definition at line 109 of file Worker.h.

References implPreForkReleaseResources().

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

{implPreForkReleaseResources();}

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

inline

Definition at line 111 of file Worker.h.

References implRegisterThinnedAssociations().

{ implRegisterThinnedAssociations(registry, helper); }

void edm::Worker::reset ( void  )

inline

Definition at line 113 of file Worker.h.

References cached_exception_, numberOfPathsLeftToRun_, numberOfPathsOn_, Ready, edm::WaitingTaskList::reset(), state_, waitingTasks_, and workStarted_.

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 225 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 107 of file Worker.h.

References implRespondToCloseInputFile().

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

{implRespondToCloseInputFile(fb);}

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

inline

Definition at line 106 of file Worker.h.

References implRespondToOpenInputFile().

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 781 of file Worker.h.

References actReg_, moduleCallingContext_, and timesRun_.

                                                        {
    //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 = workerhelper::CallImpl<T>::call(this,streamID,ep,es, actReg_.get(), &moduleCallingContext_, context);
    
    if (rc) {
      setPassed<T::isEvent_>();
    } else {
      setFailed<T::isEvent_>();
    }
    return rc;
  }

template<typename T >

void 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 631 of file Worker.h.

References cms::Exception::addContext(), assert(), cached_exception_, description(), edm::WaitingTaskList::doneWaiting(), edm::ModuleCallingContext::kInvalid, moduleCallingContext_, edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), edm::ModuleCallingContext::setContext(), shouldRethrowException(), waitingTasks_, and edm::convertException::wrap().

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

                                                                     {
    try {
      convertException::wrap([&]() {
        if(iEPtr) {
          assert(*iEPtr);
          moduleCallingContext_.setContext(ModuleCallingContext::State::kInvalid,ParentContext(),nullptr);
          std::rethrow_exception(*iEPtr);
        }

        runModule<T>(ep,es,streamID,parentContext,context);
      });
    } catch( cms::Exception& iException) {
      TransitionIDValue<typename T::MyPrincipal> idValue(ep);
      if(shouldRethrowException(iException, parentContext, T::isEvent_, idValue)) {
        assert(not cached_exception_);
        std::ostringstream iost;
        if(iEPtr) {
          iost<<"Prefetching for module ";
        } else {
          iost<<"Calling method for module ";
        }
        iost<<description().moduleName() << "/'"
        << description().moduleLabel() << "'";
        iException.addContext(iost.str());
        setException<T::isEvent_>(std::current_exception());
        waitingTasks_.doneWaiting(cached_exception_);
        return;
      } else {
        setPassed<T::isEvent_>();
      }
    }
    waitingTasks_.doneWaiting(nullptr);
  }

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 >.

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

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_, and edm::areg.

                                                                       {
    actReg_ = areg;
  }

void edm::Worker::setEarlyDeleteHelper

(

EarlyDeleteHelper *

iHelper

)

Definition at line 221 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 277 of file Worker.h.

References cached_exception_, Exception, state_, and timesExcept_.

                                                               {
      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 268 of file Worker.h.

References Fail, state_, and timesFailed_.

                     {
      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 259 of file Worker.h.

References Pass, state_, and timesPassed_.

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

bool edm::Worker::shouldRethrowException ( cms::Exception &  ex, ParentContext const &  parentContext, bool  isEvent, TransitionIDValueBase const &  iID  ) const

private

Definition at line 155 of file Worker.cc.

References mps_fire::action, actions_, cms::Exception::category(), description(), exceptionContext(), 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::Worker::TransitionIDValueBase::value().

Referenced by doWork(), and runModuleAfterAsyncPrefetch().

                                                                              {
    
    // 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.
    exception_actions::ActionCodes action = (isEvent ? actions_->find(ex.category()) : exception_actions::Rethrow);
    
    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;
    }
    switch(action) {
      case exception_actions::IgnoreCompletely:
      {
        exceptionContext(iID.value(), isEvent, ex, &tempContext);
        edm::printCmsExceptionWarning("IgnoreCompletely", ex);
        return false;
        break;
      }
      default:
        return true;
    }
  }

void edm::Worker::skipOnPath

(

)

Definition at line 311 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 162 of file Worker.h.

References state_.

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

{ return state_; }

int edm::Worker::timesExcept ( ) const

inline

Definition at line 161 of file Worker.h.

References timesExcept_.

Referenced by edm::fillWorkerSummaryAux().

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

int edm::Worker::timesFailed ( ) const

inline

Definition at line 160 of file Worker.h.

References timesFailed_.

Referenced by edm::fillWorkerSummaryAux().

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

int edm::Worker::timesPass ( ) const

inline

Definition at line 164 of file Worker.h.

References timesPassed().

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

int edm::Worker::timesPassed ( ) const

inline

Definition at line 159 of file Worker.h.

References timesPassed_.

Referenced by edm::fillWorkerSummaryAux(), and timesPass().

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

int edm::Worker::timesRun ( ) const

inline

Definition at line 157 of file Worker.h.

References timesRun_.

Referenced by edm::fillWorkerSummaryAux().

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

int edm::Worker::timesVisited ( ) const

inline

Definition at line 158 of file Worker.h.

References timesVisited_.

Referenced by edm::fillWorkerSummaryAux().

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

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 167 of file Worker.h.

Member Data Documentation

ExceptionToActionTable const* edm::Worker::actions_

private

Definition at line 393 of file Worker.h.

Referenced by shouldRethrowException().

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

private

Definition at line 396 of file Worker.h.

Referenced by activityRegistry(), beginJob(), beginStream(), doWork(), emitPostModuleEventPrefetchingSignal(), endJob(), endStream(), prefetchAsync(), runModule(), and setActivityRegistry().

std::exception_ptr edm::Worker::cached_exception_

private

Definition at line 394 of file Worker.h.

Referenced by doWork(), reset(), runModuleAfterAsyncPrefetch(), setException(), and skipOnPath().

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

private

Definition at line 398 of file Worker.h.

Referenced by postDoEvent(), and setEarlyDeleteHelper().

ModuleCallingContext edm::Worker::moduleCallingContext_

private

Definition at line 391 of file Worker.h.

Referenced by beginStream(), descPtr(), description(), doWork(), doWorkAsync(), emitPostModuleEventPrefetchingSignal(), endStream(), prefetchAsync(), resetModuleDescription(), runModule(), and runModuleAfterAsyncPrefetch().

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

private

Definition at line 389 of file Worker.h.

Referenced by reset(), and skipOnPath().

int edm::Worker::numberOfPathsOn_

private

Definition at line 388 of file Worker.h.

Referenced by addedToPath(), and reset().

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

private

Definition at line 387 of file Worker.h.

Referenced by beginJob(), beginStream(), doWork(), endJob(), endStream(), reset(), setException(), setFailed(), setPassed(), and state().

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

private

Definition at line 386 of file Worker.h.

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

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

private

Definition at line 385 of file Worker.h.

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

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

private

Definition at line 384 of file Worker.h.

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

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

private

Definition at line 382 of file Worker.h.

Referenced by clearCounters(), doWork(), runModule(), and timesRun().

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

private

Definition at line 383 of file Worker.h.

Referenced by clearCounters(), doWork(), doWorkAsync(), and timesVisited().

edm::WaitingTaskList edm::Worker::waitingTasks_

private

Definition at line 400 of file Worker.h.

Referenced by callWhenDoneAsync(), doWork(), doWorkAsync(), reset(), runModuleAfterAsyncPrefetch(), and skipOnPath().

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

private

Definition at line 401 of file Worker.h.

Referenced by doWork(), doWorkAsync(), and reset().