art::Worker Class Reference

#include "Worker.h"

Inheritance diagram for art::Worker:

Classes
struct	ImplDoWork
struct	ImplDoWork< BranchActionBegin >
struct	ImplDoWork< BranchActionEnd >
struct	ImplDoWork< BranchActionProcess >

Public Types
enum	State {   Ready, Pass, Fail, Working,   Exception }

Public Member Functions
	Worker (ModuleDescription const &iMD, WorkerParams const &iWP)
virtual	~Worker () noexcept=default
template<typename T >
bool	doWork (typename T::MyPrincipal &, CurrentProcessingContext const *cpc)
void	beginJob ()
void	endJob ()
void	respondToOpenInputFile (FileBlock const &fb)
void	respondToCloseInputFile (FileBlock const &fb)
void	respondToOpenOutputFiles (FileBlock const &fb)
void	respondToCloseOutputFiles (FileBlock const &fb)
void	reset ()
ModuleDescription const &	description () const
ModuleDescription const *	descPtr () const
void	setActivityRegistry (cet::exempt_ptr< ActivityRegistry > areg)
void	clearCounters ()
std::size_t	timesRun () const
std::size_t	timesVisited () const
std::size_t	timesPassed () const
std::size_t	timesFailed () const
std::size_t	timesExcept () const
State	state () const
virtual bool	modifiesEvent () const =0
std::string const &	label () const

Protected Member Functions
virtual std::string	workerType () const =0
virtual bool	implDoProcess (EventPrincipal &, CurrentProcessingContext const *cpc, CountingStatistics &)=0
virtual bool	implDoBegin (RunPrincipal &rp, CurrentProcessingContext const *cpc)=0
virtual bool	implDoEnd (RunPrincipal &rp, CurrentProcessingContext const *cpc)=0
virtual bool	implDoBegin (SubRunPrincipal &srp, CurrentProcessingContext const *cpc)=0
virtual bool	implDoEnd (SubRunPrincipal &srp, CurrentProcessingContext const *cpc)=0
virtual void	implBeginJob ()=0
virtual void	implEndJob ()=0

Private Member Functions
virtual void	implRespondToOpenInputFile (FileBlock const &fb)=0
virtual void	implRespondToCloseInputFile (FileBlock const &fb)=0
virtual void	implRespondToOpenOutputFiles (FileBlock const &fb)=0
virtual void	implRespondToCloseOutputFiles (FileBlock const &fb)=0

Private Attributes
CountingStatistics	counts_ {}
State	state_ {Ready}
ModuleDescription	md_
ActionTable const &	actions_
std::shared_ptr< art::Exception >	cached_exception_
cet::exempt_ptr< ActivityRegistry >	actReg_ {nullptr}

Detailed Description

Definition at line 51 of file Worker.h.

Member Enumeration Documentation

enum art::Worker::State

Enumerator
Ready
Pass
Fail
Working
Exception

Definition at line 53 of file Worker.h.

{ Ready, Pass, Fail, Working, Exception };

Constructor & Destructor Documentation

art::Worker::Worker	(	ModuleDescription const &	iMD,
		WorkerParams const &	iWP
	)

Definition at line 7 of file Worker.cc.

References actions_.

  : md_{iMD}, actions_{iWP.actions_}
{}

virtual art::Worker::~Worker ( )

virtualdefaultnoexcept

Member Function Documentation

void art::Worker::beginJob

(

)

Definition at line 18 of file Worker.cc.

References actReg_, art::errors::BadExceptionType, description(), e, implBeginJob(), md_, art::errors::OtherArt, s, art::errors::StdException, art::errors::Unknown, and workerType().

                        {
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleBeginJob.invoke(md_);
  implBeginJob();
  actReg_->sPostModuleBeginJob.invoke(md_);
}
catch (cet::exception& e) {
  // should event id be included?
  LogError("BeginJob") << "A cet::exception is going through " << workerType()
                       << ":\n";

  e << "A cet::exception is going through " << workerType() << ":\n"
    << description();
  throw art::Exception(errors::OtherArt, std::string(), e);
}
catch (std::bad_alloc& e) {
  LogError("BeginJob") << "A std::bad_alloc is going through " << workerType()
                       << ":\n"
                       << description() << "\n";
  throw;
}
catch (std::exception& e) {
  LogError("BeginJob") << "A std::exception is going through " << workerType()
                       << ":\n"
                       << description() << "\n";
  throw art::Exception(errors::StdException)
    << "A std::exception is going through " << workerType() << ":\n"
    << description() << "\n";
}
catch (std::string& s) {
  LogError("BeginJob") << "module caught an std::string during beginJob\n";

  throw art::Exception(errors::BadExceptionType)
    << "std::string = " << s << "\n"
    << description() << "\n";
}
catch (char const* c) {
  LogError("BeginJob") << "module caught an const char* during beginJob\n";

  throw art::Exception(errors::BadExceptionType) << "cstring = " << c << "\n"
                                                 << description();
}
catch (...) {
  LogError("BeginJob") << "An unknown Exception occurred in\n"
                       << description() << "\n";
  throw art::Exception(errors::Unknown) << "An unknown Exception occurred in\n"
                                        << description() << "\n";
}

void art::Worker::clearCounters ( )

inline

Definition at line 88 of file Worker.h.

References counts_.

  {
    counts_ = CountingStatistics{};
  }

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

inline

Definition at line 79 of file Worker.h.

References md_, and setActivityRegistry().

  {
    return &md_;
  }

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

inline

Definition at line 74 of file Worker.h.

References md_.

Referenced by beginJob(), art::OutputWorker::closeFile(), endJob(), art::OutputWorker::openFile(), and art::OutputWorker::OutputWorker().

  {
    return md_;
  }

template<typename T >

bool art::Worker::doWork	(	typename T::MyPrincipal &	p,
		CurrentProcessingContext const *	cpc
	)

Definition at line 218 of file Worker.h.

References actions_, actReg_, art::errors::BadAlloc, art::errors::BadExceptionType, cached_exception_, counts_, e, art::Event, Exception, art::detail::exceptionContext(), Fail, art::actions::FailModule, art::actions::FailPath, art::ActionTable::find(), art::actions::IgnoreCompletely, art::CurrentProcessingContext::isEndPath(), md_, art::errors::OtherArt, Pass, Ready, art::actions::Rethrow, s, art::errors::ScheduleExecutionFailure, art::actions::SkipEvent, state_, art::errors::StdException, art::errors::Unknown, and Working.

{
  MaybeIncrementCounts<T::level, decltype(counts_)> counts{counts_};
  counts.template increment<stats::Visited>();

  switch (state_) {
    case Ready:
      break;
    case Pass:
      return true;
    case Fail:
      return false;
    case Exception: {
      // Rethrow the cached exception again. It seems impossible to
      // get here a second time unless a cet::exception has been
      // thrown previously.
      mf::LogWarning("repeat")
        << "A module has been invoked a second time even though"
           " it caught an exception during the previous invocation."
           "\nThis may be an indication of a configuration problem.\n";
      throw *cached_exception_;
    }
    case Working:
      break; // See below.
  }

  bool rc{false};
  try {
    if (state_ == Working) {
      // Not part of the switch statement above because we want the
      // exception to be caught by our handling mechanism.
      throw art::Exception(errors::ScheduleExecutionFailure)
        << "A Module has been invoked while it is still being executed.\n"
        << "Product dependencies have invoked a module execution cycle.\n";
    }

    assert(actReg_.get() != nullptr);
    state_ = Working;

    T::preModuleSignal(*actReg_, md_);
    rc = ImplDoWork<T::processing_action>::invoke(this, p, cpc);
    T::postModuleSignal(*actReg_, md_);

    state_ = Pass;

    if (T::level == Level::Event && !rc)
      state_ = Fail;
  }
  catch (cet::exception& e) {

    // 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, subRun)
    // always rethrow.
    actions::ActionCodes action{T::level == Level::Event ?
                                  actions_.find(e.root_cause()) :
                                  actions::Rethrow};

    // If we are processing an endPath, treat SkipEvent or FailPath as
    // FailModule, so any subsequent OutputModules are still run.
    if (cpc && cpc->isEndPath()) {
      if (action == actions::SkipEvent || action == actions::FailPath)
        action = actions::FailModule;
    }

    switch (action) {
      case actions::IgnoreCompletely: {
        rc = true;
        counts.template increment<stats::Passed>();
        state_ = Pass;
        mf::LogWarning("IgnoreCompletely") << "Module ignored an exception\n"
                                           << e.what();
        break;
      }
      case actions::FailModule: {
        rc = true;
        mf::LogWarning("FailModule") << "Module failed due to an exception\n"
                                     << e.what();
        counts.template increment<stats::Failed>();
        state_ = Fail;
        break;
      }
      default: {
        // We should not need to include the event/run/module names in
        // the exception because the error logger will pick this up
        // automatically.  I'm leaving it in until this is verified.

        // here we simply add a small amount of data to the exception to
        // add some context, we could have rethrown it as something else
        // and embedded with this exception as an argument to the
        // constructor.
        counts.template increment<stats::ExceptionThrown>();
        state_ = Exception;
        e << "cet::exception going through module ";
        detail::exceptionContext(md_, p, e);
        if (auto edmEx = dynamic_cast<art::Exception*>(&e)) {
          cached_exception_ = std::make_shared<art::Exception>(*edmEx);
        } else {
          cached_exception_ = std::make_shared<art::Exception>(
            errors::OtherArt, std::string(), e);
        }
        throw;
      }
    }
  }
  catch (std::bad_alloc const& bda) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ = std::make_shared<art::Exception>(errors::BadAlloc);
    *cached_exception_
      << "A std::bad_alloc exception occurred during a call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "The job has probably exhausted the virtual memory available to the "
         "process.\n";
    throw *cached_exception_;
  }
  catch (std::exception const& e) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ = std::make_shared<art::Exception>(errors::StdException);
    *cached_exception_
      << "A std::exception occurred during a call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "and cannot be repropagated.\n"
      << "Previous information:\n"
      << e.what();
    throw *cached_exception_;
  }
  catch (std::string const& s) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ =
      std::make_shared<art::Exception>(errors::BadExceptionType, "std::string");
    *cached_exception_ << "A std::string thrown as an exception occurred "
                          "during a call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "and cannot be repropagated.\n"
      << "Previous information:\n string = " << s;
    throw *cached_exception_;
  }
  catch (char const* c) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ = std::make_shared<art::Exception>(
      errors::BadExceptionType, "const char *");
    *cached_exception_ << "A const char* thrown as an exception occurred "
                          "during a call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "and cannot be repropagated.\n"
      << "Previous information:\n const char* = " << c << "\n";
    throw *cached_exception_;
  }
  catch (...) {
    counts.template increment<stats::ExceptionThrown>();
    state_ = Exception;
    cached_exception_ =
      std::make_shared<art::Exception>(errors::Unknown, "repeated");
    *cached_exception_
      << "An unknown occurred during a previous call to the module ";
    detail::exceptionContext(md_, p, *cached_exception_)
      << "and cannot be repropagated.\n";
    throw *cached_exception_;
  }

  return rc;
}

void art::Worker::endJob

(

)

Definition at line 68 of file Worker.cc.

References actReg_, art::errors::BadExceptionType, description(), e, implEndJob(), md_, art::errors::OtherArt, s, art::errors::StdException, art::errors::Unknown, and workerType().

Referenced by art::EndPathExecutor::endJob(), and art::Schedule::endJob().

                      {
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleEndJob.invoke(md_);
  implEndJob();
  actReg_->sPostModuleEndJob.invoke(md_);
}
catch (cet::exception& e) {
  LogError("EndJob") << "A cet::exception is going through " << workerType()
                     << ":\n";

  // should event id be included?
  e << "A cet::exception is going through " << workerType() << ":\n"
    << description();
  throw art::Exception(errors::OtherArt, std::string(), e);
}
catch (std::bad_alloc& e) {
  LogError("EndJob") << "A std::bad_alloc is going through " << workerType()
                     << ":\n"
                     << description() << "\n";
  throw;
}
catch (std::exception& e) {
  LogError("EndJob") << "An std::exception is going through " << workerType()
                     << ":\n"
                     << description() << "\n";
  throw art::Exception(errors::StdException)
    << "A std::exception is going through " << workerType() << ":\n"
    << description() << "\n"
    << e.what();
}
catch (std::string& s) {
  LogError("EndJob") << "module caught an std::string during endJob\n";

  throw art::Exception(errors::BadExceptionType)
    << "std::string = " << s << "\n"
    << description() << "\n";
}
catch (char const* c) {
  LogError("EndJob") << "module caught an const char* during endJob\n";

  throw art::Exception(errors::BadExceptionType) << "cstring = " << c << "\n"
                                                 << description() << "\n";
}
catch (...) {
  LogError("EndJob") << "An unknown Exception occurred in\n"
                     << description() << "\n";
  throw art::Exception(errors::Unknown) << "An unknown Exception occurred in\n"
                                        << description() << "\n";
}

virtual void art::Worker::implBeginJob ( )

protectedpure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by beginJob(), and label().

virtual bool art::Worker::implDoBegin ( RunPrincipal &  rp, CurrentProcessingContext const *  cpc  )

protectedpure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by art::Worker::ImplDoWork< BranchActionBegin >::invoke(), and label().

virtual bool art::Worker::implDoBegin ( SubRunPrincipal &  srp, CurrentProcessingContext const *  cpc  )

protectedpure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

virtual bool art::Worker::implDoEnd ( RunPrincipal &  rp, CurrentProcessingContext const *  cpc  )

protectedpure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by art::Worker::ImplDoWork< BranchActionEnd >::invoke(), and label().

virtual bool art::Worker::implDoEnd ( SubRunPrincipal &  srp, CurrentProcessingContext const *  cpc  )

protectedpure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

virtual bool art::Worker::implDoProcess ( EventPrincipal &  , CurrentProcessingContext const *  cpc, CountingStatistics &    )

protectedpure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by art::Worker::ImplDoWork< BranchActionProcess >::invoke(), and label().

virtual void art::Worker::implEndJob ( )

protectedpure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by endJob(), and label().

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

privatepure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by respondToCloseInputFile().

virtual void art::Worker::implRespondToCloseOutputFiles ( FileBlock const &  fb )

privatepure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by respondToCloseOutputFiles().

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

privatepure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by respondToOpenInputFile().

virtual void art::Worker::implRespondToOpenOutputFiles ( FileBlock const &  fb )

privatepure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by respondToOpenOutputFiles().

std::string const& art::Worker::label ( ) const

inline

Definition at line 127 of file Worker.h.

References implBeginJob(), implDoBegin(), implDoEnd(), implDoProcess(), implEndJob(), md_, art::ModuleDescription::moduleLabel(), and workerType().

Referenced by art::EndPathExecutor::closeAllOutputFiles(), art::EndPathExecutor::openAllOutputFiles(), and art::OutputWorker::OutputWorker().

  {
    return md_.moduleLabel();
  }

virtual bool art::Worker::modifiesEvent ( ) const

pure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by state().

void art::Worker::reset ( void  )

inline

Definition at line 68 of file Worker.h.

References Ready, and state_.

  {
    state_ = Ready;
  }

void art::Worker::respondToCloseInputFile

(

FileBlock const &

fb

)

Definition at line 128 of file Worker.cc.

References actReg_, implRespondToCloseInputFile(), and md_.

{
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleRespondToCloseInputFile.invoke(md_);
  implRespondToCloseInputFile(fb);
  actReg_->sPostModuleRespondToCloseInputFile.invoke(md_);
}

void art::Worker::respondToCloseOutputFiles

(

FileBlock const &

fb

)

Definition at line 146 of file Worker.cc.

References actReg_, implRespondToCloseOutputFiles(), and md_.

{
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleRespondToCloseOutputFiles.invoke(md_);
  implRespondToCloseOutputFiles(fb);
  actReg_->sPostModuleRespondToCloseOutputFiles.invoke(md_);
}

void art::Worker::respondToOpenInputFile

(

FileBlock const &

fb

)

Definition at line 119 of file Worker.cc.

References actReg_, implRespondToOpenInputFile(), and md_.

{
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleRespondToOpenInputFile.invoke(md_);
  implRespondToOpenInputFile(fb);
  actReg_->sPostModuleRespondToOpenInputFile.invoke(md_);
}

void art::Worker::respondToOpenOutputFiles

(

FileBlock const &

fb

)

Definition at line 137 of file Worker.cc.

References actReg_, implRespondToOpenOutputFiles(), and md_.

{
  assert(actReg_.get() != nullptr);
  actReg_->sPreModuleRespondToOpenOutputFiles.invoke(md_);
  implRespondToOpenOutputFiles(fb);
  actReg_->sPostModuleRespondToOpenOutputFiles.invoke(md_);
}

void art::Worker::setActivityRegistry

(

cet::exempt_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 12 of file Worker.cc.

References actReg_.

Referenced by descPtr().

{
  actReg_ = std::move(areg);
}

State art::Worker::state ( ) const

inline

Definition at line 119 of file Worker.h.

References modifiesEvent(), and state_.

  {
    return state_;
  }

std::size_t art::Worker::timesExcept ( ) const

inline

Definition at line 114 of file Worker.h.

References counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::ExceptionThrown>();
  }

std::size_t art::Worker::timesFailed ( ) const

inline

Definition at line 109 of file Worker.h.

References counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::Failed>();
  }

std::size_t art::Worker::timesPassed ( ) const

inline

Definition at line 104 of file Worker.h.

References counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::Passed>();
  }

std::size_t art::Worker::timesRun ( ) const

inline

Definition at line 94 of file Worker.h.

References counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::Run>();
  }

std::size_t art::Worker::timesVisited ( ) const

inline

Definition at line 99 of file Worker.h.

References counts_, and art::ExecutionCounts< ARGS >::times().

  {
    return counts_.times<stats::Visited>();
  }

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

protectedpure virtual

Implemented in art::WorkerT< T >, and art::WorkerT< OutputModule >.

Referenced by beginJob(), endJob(), and label().

Member Data Documentation

ActionTable const& art::Worker::actions_

private

Definition at line 161 of file Worker.h.

Referenced by doWork(), and Worker().

cet::exempt_ptr<ActivityRegistry> art::Worker::actReg_ {nullptr}

private

Definition at line 164 of file Worker.h.

Referenced by beginJob(), doWork(), endJob(), respondToCloseInputFile(), respondToCloseOutputFiles(), respondToOpenInputFile(), respondToOpenOutputFiles(), and setActivityRegistry().

std::shared_ptr<art::Exception> art::Worker::cached_exception_

private

Initial value:

{
    nullptr}

Definition at line 162 of file Worker.h.

Referenced by doWork().

CountingStatistics art::Worker::counts_ {}

private

Definition at line 157 of file Worker.h.

Referenced by clearCounters(), doWork(), art::Worker::ImplDoWork< BranchActionProcess >::invoke(), timesExcept(), timesFailed(), timesPassed(), timesRun(), and timesVisited().

ModuleDescription art::Worker::md_

private

Definition at line 160 of file Worker.h.

Referenced by beginJob(), descPtr(), description(), doWork(), endJob(), label(), respondToCloseInputFile(), respondToCloseOutputFiles(), respondToOpenInputFile(), and respondToOpenOutputFiles().

State art::Worker::state_ {Ready}

private

Definition at line 158 of file Worker.h.

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

---

The documentation for this class was generated from the following files:

• art/Framework/Principal/Worker.h
• art/Framework/Principal/Worker.cc