Classes | Public Types | Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes | List of all members
art::Worker Class Referenceabstract

#include "/cvmfs/nova.opensciencegrid.org/externals/art/v2_13_00/source/art/Framework/Principal/Worker.h"

Inheritance diagram for art::Worker:
art::WorkerT< T > art::WorkerT< OutputModule > art::OutputWorker

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::Exceptioncached_exception_
 
cet::exempt_ptr< ActivityRegistryactReg_ {nullptr}
 

Detailed Description

Definition at line 51 of file Worker.h.

Member Enumeration Documentation

Enumerator
Ready 
Pass 
Fail 
Working 
Exception 

Definition at line 53 of file Worker.h.

Constructor & Destructor Documentation

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

Member Function Documentation

void art::Worker::beginJob ( )
void art::Worker::clearCounters ( )
inline

Definition at line 88 of file Worker.h.

References counts_.

89  {
91  }
CountingStatistics counts_
Definition: Worker.h:157
ExecutionCounts< stats::Visited, stats::Run, stats::Passed, stats::Failed, stats::ExceptionThrown > CountingStatistics
ModuleDescription const* art::Worker::descPtr ( ) const
inline

Definition at line 79 of file Worker.h.

References md_, and setActivityRegistry().

80  {
81  return &md_;
82  }
ModuleDescription md_
Definition: Worker.h:160
ModuleDescription const& art::Worker::description ( ) const
inline

Definition at line 74 of file Worker.h.

References md_.

75  {
76  return md_;
77  }
ModuleDescription md_
Definition: Worker.h:160
template<typename T >
bool art::Worker::doWork ( typename T::MyPrincipal &  p,
CurrentProcessingContext const *  cpc 
)

Definition at line 218 of file Worker.h.

References plot_validation_datamc::action, actions_, actReg_, ana::assert(), art::errors::BadAlloc, art::errors::BadExceptionType, plot_validation_datamc::c, 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, submit_cafana::rc, Ready, art::actions::Rethrow, art::errors::ScheduleExecutionFailure, art::actions::SkipEvent, state_, art::errors::StdException, string, art::errors::Unknown, and Working.

220 {
221  MaybeIncrementCounts<T::level, decltype(counts_)> counts{counts_};
222  counts.template increment<stats::Visited>();
223 
224  switch (state_) {
225  case Ready:
226  break;
227  case Pass:
228  return true;
229  case Fail:
230  return false;
231  case Exception: {
232  // Rethrow the cached exception again. It seems impossible to
233  // get here a second time unless a cet::exception has been
234  // thrown previously.
235  mf::LogWarning("repeat")
236  << "A module has been invoked a second time even though"
237  " it caught an exception during the previous invocation."
238  "\nThis may be an indication of a configuration problem.\n";
239  throw *cached_exception_;
240  }
241  case Working:
242  break; // See below.
243  }
244 
245  bool rc{false};
246  try {
247  if (state_ == Working) {
248  // Not part of the switch statement above because we want the
249  // exception to be caught by our handling mechanism.
251  << "A Module has been invoked while it is still being executed.\n"
252  << "Product dependencies have invoked a module execution cycle.\n";
253  }
254 
255  assert(actReg_.get() != nullptr);
256  state_ = Working;
257 
258  T::preModuleSignal(*actReg_, md_);
259  rc = ImplDoWork<T::processing_action>::invoke(this, p, cpc);
260  T::postModuleSignal(*actReg_, md_);
261 
262  state_ = Pass;
263 
264  if (T::level == Level::Event && !rc)
265  state_ = Fail;
266  }
267  catch (cet::exception& e) {
268 
269  // NOTE: the warning printed as a result of ignoring or failing a
270  // module will only be printed during the full true processing
271  // pass of this module.
272 
273  // Get the action corresponding to this exception. However, if
274  // processing something other than an event (e.g. run, subRun)
275  // always rethrow.
277  actions_.find(e.root_cause()) :
279 
280  // If we are processing an endPath, treat SkipEvent or FailPath as
281  // FailModule, so any subsequent OutputModules are still run.
282  if (cpc && cpc->isEndPath()) {
285  }
286 
287  switch (action) {
289  rc = true;
290  counts.template increment<stats::Passed>();
291  state_ = Pass;
292  mf::LogWarning("IgnoreCompletely") << "Module ignored an exception\n"
293  << e.what();
294  break;
295  }
296  case actions::FailModule: {
297  rc = true;
298  mf::LogWarning("FailModule") << "Module failed due to an exception\n"
299  << e.what();
300  counts.template increment<stats::Failed>();
301  state_ = Fail;
302  break;
303  }
304  default: {
305  // We should not need to include the event/run/module names in
306  // the exception because the error logger will pick this up
307  // automatically. I'm leaving it in until this is verified.
308 
309  // here we simply add a small amount of data to the exception to
310  // add some context, we could have rethrown it as something else
311  // and embedded with this exception as an argument to the
312  // constructor.
313  counts.template increment<stats::ExceptionThrown>();
314  state_ = Exception;
315  e << "cet::exception going through module ";
317  if (auto edmEx = dynamic_cast<art::Exception*>(&e)) {
318  cached_exception_ = std::make_shared<art::Exception>(*edmEx);
319  } else {
320  cached_exception_ = std::make_shared<art::Exception>(
322  }
323  throw;
324  }
325  }
326  }
327  catch (std::bad_alloc const& bda) {
328  counts.template increment<stats::ExceptionThrown>();
329  state_ = Exception;
330  cached_exception_ = std::make_shared<art::Exception>(errors::BadAlloc);
332  << "A std::bad_alloc exception occurred during a call to the module ";
333  detail::exceptionContext(md_, p, *cached_exception_)
334  << "The job has probably exhausted the virtual memory available to the "
335  "process.\n";
336  throw *cached_exception_;
337  }
338  catch (std::exception const& e) {
339  counts.template increment<stats::ExceptionThrown>();
340  state_ = Exception;
341  cached_exception_ = std::make_shared<art::Exception>(errors::StdException);
343  << "A std::exception occurred during a call to the module ";
344  detail::exceptionContext(md_, p, *cached_exception_)
345  << "and cannot be repropagated.\n"
346  << "Previous information:\n"
347  << e.what();
348  throw *cached_exception_;
349  }
350  catch (std::string const& s) {
351  counts.template increment<stats::ExceptionThrown>();
352  state_ = Exception;
353  cached_exception_ =
354  std::make_shared<art::Exception>(errors::BadExceptionType, "std::string");
355  *cached_exception_ << "A std::string thrown as an exception occurred "
356  "during a call to the module ";
357  detail::exceptionContext(md_, p, *cached_exception_)
358  << "and cannot be repropagated.\n"
359  << "Previous information:\n string = " << s;
360  throw *cached_exception_;
361  }
362  catch (char const* c) {
363  counts.template increment<stats::ExceptionThrown>();
364  state_ = Exception;
365  cached_exception_ = std::make_shared<art::Exception>(
366  errors::BadExceptionType, "const char *");
367  *cached_exception_ << "A const char* thrown as an exception occurred "
368  "during a call to the module ";
369  detail::exceptionContext(md_, p, *cached_exception_)
370  << "and cannot be repropagated.\n"
371  << "Previous information:\n const char* = " << c << "\n";
372  throw *cached_exception_;
373  }
374  catch (...) {
375  counts.template increment<stats::ExceptionThrown>();
376  state_ = Exception;
377  cached_exception_ =
378  std::make_shared<art::Exception>(errors::Unknown, "repeated");
379  *cached_exception_
380  << "An unknown occurred during a previous call to the module ";
381  detail::exceptionContext(md_, p, *cached_exception_)
382  << "and cannot be repropagated.\n";
383  throw *cached_exception_;
384  }
385 
386  return rc;
387 }
actions::ActionCodes find(std::string const &category) const
const char * p
Definition: xmltok.h:285
CountingStatistics counts_
Definition: Worker.h:157
::xsd::cxx::tree::exception< char > exception
Definition: Database.h:225
ActionTable const & actions_
Definition: Worker.h:161
cet::exception & exceptionContext(ModuleDescription const &md, T const &ip, cet::exception &ex)
Definition: Worker.h:208
const XML_Char * s
Definition: expat.h:262
std::shared_ptr< art::Exception > cached_exception_
Definition: Worker.h:162
cet::exempt_ptr< ActivityRegistry > actReg_
Definition: Worker.h:164
ModuleDescription md_
Definition: Worker.h:160
State state_
Definition: Worker.h:158
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
assert(nhit_max >=nhit_nbins)
Float_t e
Definition: plot.C:35
enum BeamMode string
void art::Worker::endJob ( )
virtual void art::Worker::implBeginJob ( )
protectedpure virtual

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

Referenced by label().

virtual bool art::Worker::implDoBegin ( RunPrincipal rp,
CurrentProcessingContext const *  cpc 
)
protectedpure virtual
virtual bool art::Worker::implDoBegin ( SubRunPrincipal srp,
CurrentProcessingContext const *  cpc 
)
protectedpure virtual
virtual bool art::Worker::implDoEnd ( RunPrincipal rp,
CurrentProcessingContext const *  cpc 
)
protectedpure virtual
virtual bool art::Worker::implDoEnd ( SubRunPrincipal srp,
CurrentProcessingContext const *  cpc 
)
protectedpure virtual
virtual bool art::Worker::implDoProcess ( EventPrincipal ,
CurrentProcessingContext const *  cpc,
CountingStatistics  
)
protectedpure virtual
virtual void art::Worker::implEndJob ( )
protectedpure virtual

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

Referenced by label().

virtual void art::Worker::implRespondToCloseInputFile ( FileBlock const &  fb)
privatepure virtual
virtual void art::Worker::implRespondToCloseOutputFiles ( FileBlock const &  fb)
privatepure virtual
virtual void art::Worker::implRespondToOpenInputFile ( FileBlock const &  fb)
privatepure virtual
virtual void art::Worker::implRespondToOpenOutputFiles ( FileBlock const &  fb)
privatepure virtual
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(), string, and workerType().

128  {
129  return md_.moduleLabel();
130  }
ModuleDescription md_
Definition: Worker.h:160
std::string const & moduleLabel() const
virtual bool art::Worker::modifiesEvent ( ) const
pure virtual

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

Referenced by state().

void art::Worker::reset ( )
inline

Definition at line 68 of file Worker.h.

References Ready, and state_.

69  {
70  state_ = Ready;
71  }
State state_
Definition: Worker.h:158
void art::Worker::respondToCloseInputFile ( FileBlock const &  fb)
void art::Worker::respondToCloseOutputFiles ( FileBlock const &  fb)
void art::Worker::respondToOpenInputFile ( FileBlock const &  fb)
void art::Worker::respondToOpenOutputFiles ( FileBlock const &  fb)
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

Referenced by descPtr().

State art::Worker::state ( ) const
inline

Definition at line 119 of file Worker.h.

References modifiesEvent(), state_, and string.

120  {
121  return state_;
122  }
State state_
Definition: Worker.h:158
std::size_t art::Worker::timesExcept ( ) const
inline

Definition at line 114 of file Worker.h.

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

115  {
116  return counts_.times<stats::ExceptionThrown>();
117  }
CountingStatistics counts_
Definition: Worker.h:157
std::size_t times() const
std::size_t art::Worker::timesFailed ( ) const
inline

Definition at line 109 of file Worker.h.

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

110  {
111  return counts_.times<stats::Failed>();
112  }
CountingStatistics counts_
Definition: Worker.h:157
std::size_t times() const
std::size_t art::Worker::timesPassed ( ) const
inline

Definition at line 104 of file Worker.h.

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

105  {
106  return counts_.times<stats::Passed>();
107  }
CountingStatistics counts_
Definition: Worker.h:157
std::size_t times() const
std::size_t art::Worker::timesRun ( ) const
inline

Definition at line 94 of file Worker.h.

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

95  {
96  return counts_.times<stats::Run>();
97  }
CountingStatistics counts_
Definition: Worker.h:157
std::size_t times() const
std::size_t art::Worker::timesVisited ( ) const
inline

Definition at line 99 of file Worker.h.

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

100  {
101  return counts_.times<stats::Visited>();
102  }
CountingStatistics counts_
Definition: Worker.h:157
std::size_t times() const
virtual std::string art::Worker::workerType ( ) const
protectedpure virtual

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

Referenced by label().

Member Data Documentation

ActionTable const& art::Worker::actions_
private

Definition at line 161 of file Worker.h.

Referenced by doWork().

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

Definition at line 164 of file Worker.h.

Referenced by doWork().

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
ModuleDescription art::Worker::md_
private

Definition at line 160 of file Worker.h.

Referenced by descPtr(), description(), doWork(), and label().

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 file: