edm::WorkerInPath Class Reference

#include <WorkerInPath.h>

Public Types
enum	FilterAction { Normal = 0, Ignore, Veto }

Public Member Functions
bool	checkResultsOfRunWorker (bool wasEvent)
void	clearCounters ()
FilterAction	filterAction () const
Worker *	getWorker () const
bool	runConcurrently () const noexcept
template<typename T >
void	runWorkerAsync (WaitingTask *, typename T::TransitionInfoType const &, ServiceToken const &, StreamID, typename T::Context const *)
void	setPathContext (PathContext const *v)
void	skipWorker (EventPrincipal const &iPrincipal)
void	skipWorker (LuminosityBlockPrincipal const &)
void	skipWorker (RunPrincipal const &)
int	timesExcept () const
int	timesFailed () const
int	timesPassed () const
int	timesVisited () const
	WorkerInPath (Worker *, FilterAction theAction, unsigned int placeInPath, bool runConcurrently)

Private Attributes
FilterAction	filterAction_
PlaceInPathContext	placeInPathContext_
bool	runConcurrently_
int	timesExcept_
int	timesFailed_
int	timesPassed_
int	timesVisited_
Worker *	worker_

Detailed Description

Definition at line 25 of file WorkerInPath.h.

Member Enumeration Documentation

FilterAction

enum edm::WorkerInPath::FilterAction

Enumerator
Normal
Ignore
Veto

Definition at line 27 of file WorkerInPath.h.

{ Normal = 0, Ignore, Veto };

Constructor & Destructor Documentation

WorkerInPath()

edm::WorkerInPath::WorkerInPath	(	Worker *	w,
		FilterAction	theAction,
		unsigned int	placeInPath,
		bool	runConcurrently
	)

Definition at line 6 of file WorkerInPath.cc.

      : timesVisited_(),
        timesPassed_(),
        timesFailed_(),
        timesExcept_(),
        filterAction_(theFilterAction),
        worker_(w),
        placeInPathContext_(placeInPath),
        runConcurrently_(runConcurrently) {
    w->addedToPath();
  }

References w.

Member Function Documentation

checkResultsOfRunWorker()

bool edm::WorkerInPath::checkResultsOfRunWorker ( bool  wasEvent )

inline

Definition at line 67 of file WorkerInPath.h.

                                                                 {
    if (not wasEvent) {
      return true;
    }
    auto state = worker_->state();
    bool rc = true;
    switch (state) {
      case Worker::Fail: {
        rc = false;
        break;
      }
      case Worker::Pass:
        break;
      case Worker::Exception: {
        ++timesExcept_;
        return true;
      }
 
      default:
        assert(false);
    }
 
    if (Ignore == filterAction()) {
      rc = true;
    } else if (Veto == filterAction()) {
      rc = !rc;
    }
 
    if (rc) {
      ++timesPassed_;
    } else {
      ++timesFailed_;
    }
    return rc;
  }

References cms::cuda::assert(), edm::Worker::Exception, edm::Worker::Fail, filterAction(), Ignore, edm::Worker::Pass, edm::Worker::state(), timesExcept_, timesFailed_, timesPassed_, Veto, and worker_.

clearCounters()

void edm::WorkerInPath::clearCounters ( )

inline

Definition at line 41 of file WorkerInPath.h.

{ timesVisited_ = timesPassed_ = timesFailed_ = timesExcept_ = 0; }

References timesExcept_, timesFailed_, timesPassed_, and timesVisited_.

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

filterAction()

FilterAction edm::WorkerInPath::filterAction ( ) const

inline

Definition at line 48 of file WorkerInPath.h.

{ return filterAction_; }

References filterAction_.

Referenced by checkResultsOfRunWorker().

getWorker()

Worker* edm::WorkerInPath::getWorker ( ) const

inline

Definition at line 49 of file WorkerInPath.h.

{ return worker_; }

References worker_.

runConcurrently()

bool edm::WorkerInPath::runConcurrently ( ) const

inlinenoexcept

Definition at line 50 of file WorkerInPath.h.

{ return runConcurrently_; }

References runConcurrently_.

runWorkerAsync()

template<typename T >

void edm::WorkerInPath::runWorkerAsync	(	WaitingTask *	iTask,
		typename T::TransitionInfoType const &	info,
		ServiceToken const &	token,
		StreamID	streamID,
		typename T::Context const *	context
	)

Definition at line 104 of file WorkerInPath.h.

                                                                      {
    if constexpr (T::isEvent_) {
      ++timesVisited_;
    }
 
    if constexpr (T::isEvent_) {
      ParentContext parentContext(&placeInPathContext_);
      worker_->doWorkAsync<T>(iTask, info, token, streamID, parentContext, context);
    } else {
      ParentContext parentContext(context);
 
      // We do not need to run prefetching here because this only handles
      // stream transitions for runs and lumis. There are no products put
      // into the runs or lumis in stream transitions, so there can be
      // no data dependencies which require prefetching. Prefetching is
      // needed for global transitions, but they are run elsewhere.
      worker_->doWorkNoPrefetchingAsync<T>(iTask, info, token, streamID, parentContext, context);
    }
  }

References edm::Worker::doWorkAsync(), edm::Worker::doWorkNoPrefetchingAsync(), info(), placeInPathContext_, timesVisited_, unpackBuffers-CaloStage2::token, and worker_.

setPathContext()

void edm::WorkerInPath::setPathContext ( PathContext const *  v )

inline

Definition at line 52 of file WorkerInPath.h.

{ placeInPathContext_.setPathContext(v); }

References placeInPathContext_, edm::PlaceInPathContext::setPathContext(), and findQualityFiles::v.

skipWorker() [1/3]

void edm::WorkerInPath::skipWorker ( EventPrincipal const &  iPrincipal )

inline

Definition at line 37 of file WorkerInPath.h.

{ worker_->skipOnPath(iPrincipal); }

References edm::Worker::skipOnPath(), and worker_.

skipWorker() [2/3]

void edm::WorkerInPath::skipWorker ( LuminosityBlockPrincipal const &  )

inline

Definition at line 39 of file WorkerInPath.h.

{}

skipWorker() [3/3]

void edm::WorkerInPath::skipWorker ( RunPrincipal const &  )

inline

Definition at line 38 of file WorkerInPath.h.

{}

timesExcept()

int edm::WorkerInPath::timesExcept ( ) const

inline

Definition at line 46 of file WorkerInPath.h.

{ return timesExcept_; }

References timesExcept_.

timesFailed()

int edm::WorkerInPath::timesFailed ( ) const

inline

Definition at line 45 of file WorkerInPath.h.

{ return timesFailed_; }

References timesFailed_.

timesPassed()

int edm::WorkerInPath::timesPassed ( ) const

inline

Definition at line 44 of file WorkerInPath.h.

{ return timesPassed_; }

References timesPassed_.

timesVisited()

int edm::WorkerInPath::timesVisited ( ) const

inline

Definition at line 43 of file WorkerInPath.h.

{ return timesVisited_; }

References timesVisited_.

Member Data Documentation

filterAction_

FilterAction edm::WorkerInPath::filterAction_

private

Definition at line 60 of file WorkerInPath.h.

Referenced by filterAction().

placeInPathContext_

PlaceInPathContext edm::WorkerInPath::placeInPathContext_

private

Definition at line 63 of file WorkerInPath.h.

Referenced by runWorkerAsync(), and setPathContext().

runConcurrently_

bool edm::WorkerInPath::runConcurrently_

private

Definition at line 64 of file WorkerInPath.h.

Referenced by runConcurrently().

timesExcept_

int edm::WorkerInPath::timesExcept_

private

Definition at line 58 of file WorkerInPath.h.

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

timesFailed_

int edm::WorkerInPath::timesFailed_

private

Definition at line 57 of file WorkerInPath.h.

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

timesPassed_

int edm::WorkerInPath::timesPassed_

private

Definition at line 56 of file WorkerInPath.h.

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

timesVisited_

int edm::WorkerInPath::timesVisited_

private

Definition at line 55 of file WorkerInPath.h.

Referenced by clearCounters(), runWorkerAsync(), and timesVisited().

worker_

Worker* edm::WorkerInPath::worker_

private

Definition at line 61 of file WorkerInPath.h.

Referenced by checkResultsOfRunWorker(), getWorker(), runWorkerAsync(), and skipWorker().