#include "WorkerT.h"

Inheritance diagram for art::WorkerT< T >:

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

Public Member Functions
	WorkerT (T *, WorkerParams const &)

void	beginJob (detail::SharedResources const &)

void	endJob ()

void	respondToOpenInputFile (FileBlock const &fb)

void	respondToCloseInputFile (FileBlock const &fb)

void	respondToOpenOutputFiles (FileBlock const &fb)

void	respondToCloseOutputFiles (FileBlock const &fb)

void	doWork (Transition, Principal &, ModuleContext const &)

void	doWork_event (hep::concurrency::WaitingTaskPtr workerInPathDoneTask, EventPrincipal &, ModuleContext const &)

void	doWork_event (EventPrincipal &, ModuleContext const &)

ScheduleID	scheduleID () const

bool	returnCode () const

ModuleDescription const &	description () const

hep::concurrency::SerialTaskQueueChain *	serialTaskQueueChain () const

void	reset ()

std::size_t	timesVisited () const

std::size_t	timesRun () const

std::size_t	timesPassed () const

std::size_t	timesFailed () const

std::size_t	timesExcept () const

void	runWorker (EventPrincipal &, ModuleContext const &)

bool	isUnique () const

Protected Member Functions
std::string const &	label () const

Protected Attributes
std::atomic< std::size_t >	counts_visited_ {}

std::atomic< std::size_t >	counts_run_ {}

std::atomic< std::size_t >	counts_passed_ {}

std::atomic< std::size_t >	counts_failed_ {}

std::atomic< std::size_t >	counts_thrown_ {}

Private Member Functions
hep::concurrency::SerialTaskQueueChain *	doSerialTaskQueueChain () const override

void	doBeginJob (detail::SharedResources const &) override

void	doEndJob () override

void	doRespondToOpenInputFile (FileBlock const &) override

void	doRespondToCloseInputFile (FileBlock const &) override

void	doRespondToOpenOutputFiles (FileBlock const &) override

void	doRespondToCloseOutputFiles (FileBlock const &) override

void	doBegin (RunPrincipal &, ModuleContext const &) override

void	doEnd (RunPrincipal &, ModuleContext const &) override

void	doBegin (SubRunPrincipal &, ModuleContext const &) override

void	doEnd (SubRunPrincipal &, ModuleContext const &) override

bool	doProcess (EventPrincipal &, ModuleContext const &) override

Private Attributes
cet::exempt_ptr< T >	module_

Detailed Description

template<typename T>
class art::WorkerT< T >

Definition at line 19 of file WorkerT.h.

Member Enumeration Documentation

enum art::Worker::State

inherited

Enumerator
Ready
Pass
Fail
Working
ExceptionThrown

Definition at line 49 of file Worker.h.

49 { Ready, Pass, Fail, Working, ExceptionThrown };

art::Worker::Working

Definition: Worker.h:49

art::Worker::Ready

Definition: Worker.h:49

art::Worker::Fail

Definition: Worker.h:49

art::Worker::Pass

Definition: Worker.h:49

art::Worker::ExceptionThrown

Definition: Worker.h:49

Constructor & Destructor Documentation

template<typename T >

art::WorkerT< T >::WorkerT	(	T *	module,
		WorkerParams const &	wp
	)

Definition at line 51 of file WorkerT.h.

References art::ScheduleID::first(), art::module, and art::WorkerT< T >::module_.

     : Worker{module->moduleDescription(), wp}, module_{module}
   {
     if constexpr (std::is_base_of_v<Modifier, T>) {
       if (wp.scheduleID_ == ScheduleID::first()) {
         // We only want to register the products, not once for every
         // schedule...
         module_->registerProducts(wp.producedProducts_);
       } else {
         // ...but we need to fill product descriptions for each module
         // copy.
         module_->fillProductDescriptions();
       }
     }
 
     // Register shared resources only once
     if constexpr (std::is_base_of_v<detail::SharedModule, T>) {
       if (wp.scheduleID_ == ScheduleID::first()) {
         wp.resources_.registerSharedResources(module_->sharedResources());
       }
     }
   }

Member Function Documentation

void art::Worker::beginJob ( detail::SharedResources const & resources )

inherited

Definition at line 196 of file Worker.cc.

References art::Worker::actReg_, art::Worker::doBeginJob(), art::Worker::md_, art::ActivityRegistry::sPostModuleBeginJob, and art::ActivityRegistry::sPreModuleBeginJob.

       {
     actReg_.sPreModuleBeginJob.invoke(md_);
     doBeginJob(resources);
     actReg_.sPostModuleBeginJob.invoke(md_);
   }
   catch (...) {
     rethrow_with_context(std::current_exception(), md_, "beginJob");
   }

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

inherited

Definition at line 121 of file Worker.cc.

References art::Worker::md_.

Referenced by art::OutputWorker::OutputWorker(), and art::OutputWorker::writeEvent().

   {
     return md_;
   }

template<typename T >

void art::WorkerT< T >::doBegin	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 129 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doBeginRun(rp, mc);
   }

template<typename T >

void art::WorkerT< T >::doBegin	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 143 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doBeginSubRun(srp, mc);
   }

template<typename T >

void art::WorkerT< T >::doBeginJob ( detail::SharedResources const & resources )

overrideprivatevirtual

Implements art::Worker.

Definition at line 87 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doBeginJob(resources);
   }

template<typename T >

void art::WorkerT< T >::doEnd	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 136 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doEndRun(rp, mc);
   }

template<typename T >

void art::WorkerT< T >::doEnd	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 150 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doEndSubRun(srp, mc);
   }

template<typename T >

void art::WorkerT< T >::doEndJob ( )

overrideprivatevirtual

Implements art::Worker.

Definition at line 94 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doEndJob();
   }

template<typename T >

bool art::WorkerT< T >::doProcess	(	EventPrincipal &	ep,
		ModuleContext const &	mc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 157 of file WorkerT.h.

References art::Worker::counts_failed_, art::Worker::counts_passed_, art::Worker::counts_run_, and art::WorkerT< T >::module_.

   {
     // Note, only filters ever return false, and when they do it means
     // they have rejected.
     return module_->doEvent(
       ep, mc, counts_run_, counts_passed_, counts_failed_);
   }

template<typename T >

void art::WorkerT< T >::doRespondToCloseInputFile ( FileBlock const & fb )

overrideprivatevirtual

Implements art::Worker.

Definition at line 108 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doRespondToCloseInputFile(fb);
   }

template<typename T >

void art::WorkerT< T >::doRespondToCloseOutputFiles ( FileBlock const & fb )

overrideprivatevirtual

Implements art::Worker.

Definition at line 122 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doRespondToCloseOutputFiles(fb);
   }

template<typename T >

void art::WorkerT< T >::doRespondToOpenInputFile ( FileBlock const & fb )

overrideprivatevirtual

Implements art::Worker.

Definition at line 101 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doRespondToOpenInputFile(fb);
   }

template<typename T >

void art::WorkerT< T >::doRespondToOpenOutputFiles ( FileBlock const & fb )

overrideprivatevirtual

Implements art::Worker.

Definition at line 115 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     module_->doRespondToOpenOutputFiles(fb);
   }

template<typename T >

hep::concurrency::SerialTaskQueueChain * art::WorkerT< T >::doSerialTaskQueueChain ( ) const

overrideprivatevirtual

Implements art::Worker.

Definition at line 76 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     if constexpr (std::is_base_of_v<detail::SharedModule, T>) {
       return module_->serialTaskQueueChain();
     } else {
       return nullptr;
     }
   }

void art::Worker::doWork	(	Transition	trans,
		Principal &	principal,
		ModuleContext const &	mc
	)

inherited

Definition at line 250 of file Worker.cc.

References art::Worker::actReg_, art::errors::BadAlloc, art::errors::BadExceptionType, art::BeginRun, art::BeginSubRun, art::Worker::cached_exception_, art::Worker::doBegin(), art::Worker::doEnd(), art::EndRun, art::EndSubRun, art::Worker::ExceptionThrown, art::Worker::Fail, art::Worker::md_, art::errors::OtherArt, art::Worker::Pass, art::Worker::Ready, art::errors::ScheduleExecutionFailure, art::ActivityRegistry::sPostModuleBeginRun, art::ActivityRegistry::sPostModuleBeginSubRun, art::ActivityRegistry::sPostModuleEndRun, art::ActivityRegistry::sPostModuleEndSubRun, art::ActivityRegistry::sPreModuleBeginRun, art::ActivityRegistry::sPreModuleBeginSubRun, art::ActivityRegistry::sPreModuleEndRun, art::ActivityRegistry::sPreModuleEndSubRun, art::Worker::state_, art::errors::StdException, art::errors::Unknown, and art::Worker::Working.

   {
     switch (state_.load()) {
     case Ready:
       break;
     case Pass:
     case Fail:
       return;
     case ExceptionThrown: {
       // 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.";
       rethrow_exception(cached_exception_);
     }
     case Working:
       break; // See below.
     }
 
     try {
       if (state_.load() == Working) {
         // Not part of the switch statement above because we want the
         // exception to be caught by our handling mechanism.
         throw Exception(errors::ScheduleExecutionFailure)
           << "A Module has been invoked while it is still being executed.\n"
           << "Product dependencies have invoked a module execution cycle.\n";
       }
       state_ = Working;
       if (trans == Transition::BeginRun) {
         actReg_.sPreModuleBeginRun.invoke(mc);
         doBegin(dynamic_cast<RunPrincipal&>(principal), mc);
         actReg_.sPostModuleBeginRun.invoke(mc);
       } else if (trans == Transition::EndRun) {
         actReg_.sPreModuleEndRun.invoke(mc);
         doEnd(dynamic_cast<RunPrincipal&>(principal), mc);
         actReg_.sPostModuleEndRun.invoke(mc);
       } else if (trans == Transition::BeginSubRun) {
         actReg_.sPreModuleBeginSubRun.invoke(mc);
         doBegin(dynamic_cast<SubRunPrincipal&>(principal), mc);
         actReg_.sPostModuleBeginSubRun.invoke(mc);
       } else if (trans == Transition::EndSubRun) {
         actReg_.sPreModuleEndSubRun.invoke(mc);
         doEnd(dynamic_cast<SubRunPrincipal&>(principal), mc);
         actReg_.sPostModuleEndSubRun.invoke(mc);
       }
       state_ = Pass;
     }
     catch (cet::exception& e) {
       state_ = ExceptionThrown;
       e << "The above exception was thrown while processing module "
         << brief_context(md_, principal) << '\n';
       if (auto edmEx = dynamic_cast<Exception*>(&e)) {
         cached_exception_ = std::make_exception_ptr(*edmEx);
       } else {
         auto art_ex = Exception{errors::OtherArt, std::string(), e};
         cached_exception_ = std::make_exception_ptr(art_ex);
       }
       throw;
     }
     catch (std::bad_alloc const& bda) {
       state_ = ExceptionThrown;
       auto art_ex =
         Exception{errors::BadAlloc}
         << "A bad_alloc exception occurred during a call to the module "
         << brief_context(md_, principal) << '\n'
         << "The job has probably exhausted the virtual memory available to the "
            "process.\n";
       cached_exception_ = make_exception_ptr(art_ex);
       rethrow_exception(cached_exception_);
     }
     catch (std::exception const& e) {
       state_ = ExceptionThrown;
       auto art_ex = Exception{errors::StdException}
                     << "An exception occurred during a call to the module "
                     << brief_context(md_, principal) << e.what();
       cached_exception_ = make_exception_ptr(art_ex);
       rethrow_exception(cached_exception_);
     }
     catch (std::string const& s) {
       state_ = ExceptionThrown;
       auto art_ex = Exception{errors::BadExceptionType, "string"}
                     << "A string thrown as an exception occurred during a call "
                        "to the module "
                     << brief_context(md_, principal) << '\n'
                     << s << '\n';
       cached_exception_ = make_exception_ptr(art_ex);
       rethrow_exception(cached_exception_);
     }
     catch (char const* c) {
       state_ = ExceptionThrown;
       auto art_ex = Exception{errors::BadExceptionType, "char const*"}
                     << "A char const* thrown as an exception occurred during a "
                        "call to the module "
                     << brief_context(md_, principal) << '\n'
                     << c << '\n';
       cached_exception_ = make_exception_ptr(art_ex);
       rethrow_exception(cached_exception_);
     }
     catch (...) {
       state_ = ExceptionThrown;
       auto art_ex =
         Exception{errors::Unknown, "repeated"}
         << "An unknown occurred during a previous call to the module "
         << brief_context(md_, principal) << '\n';
       cached_exception_ = make_exception_ptr(art_ex);
       rethrow_exception(cached_exception_);
     }
   }

void art::Worker::doWork_event	(	hep::concurrency::WaitingTaskPtr	workerInPathDoneTask,
		EventPrincipal &	,
		ModuleContext const &
	)

inherited

Referenced by art::Worker::isUnique().

void art::Worker::doWork_event	(	EventPrincipal &	p,
		ModuleContext const &	mc
	)

inherited

Definition at line 366 of file Worker.cc.

References art::Worker::actions_, art::Worker::actReg_, art::errors::BadAlloc, art::errors::BadExceptionType, art::Worker::cached_exception_, art::Worker::counts_failed_, art::Worker::counts_passed_, art::Worker::counts_thrown_, art::Worker::counts_visited_, art::Worker::doProcess(), art::Worker::ExceptionThrown, art::Worker::Fail, art::actions::FailModule, art::ActionTable::find(), art::actions::IgnoreCompletely, art::Worker::md_, art::errors::OtherArt, art::Worker::Pass, art::Worker::returnCode_, art::ActivityRegistry::sPostModule, art::ActivityRegistry::sPreModule, art::Worker::state_, art::errors::StdException, art::errors::Unknown, and art::Worker::Working.

       {
     ++counts_visited_;
     returnCode_ = false;
     // Transition from Ready state to Working state.
     state_ = Working;
     actReg_.sPreModule.invoke(mc);
     // Note: Only the TriggerResults inserter--a producer--calls this
     // function.  The return code is thus always true.
     returnCode_ = doProcess(p, mc);
     actReg_.sPostModule.invoke(mc);
     assert(returnCode_.load());
     state_ = Pass;
   }
   catch (cet::exception& e) {
     auto action = actions_.find(e.root_cause());
     assert(not mc.onEndPath());
     if (action == actions::IgnoreCompletely) {
       state_ = Pass;
       returnCode_ = true;
       ++counts_passed_;
       mf::LogWarning("IgnoreCompletely") << "Module ignored an exception\n"
                                          << e.what();
       // WARNING: We will continue execution below!!!
     } else if (action == actions::FailModule) {
       state_ = Fail;
       returnCode_ = true;
       ++counts_failed_;
       mf::LogWarning("FailModule") << "Module failed due to an exception\n"
                                    << e.what();
       // WARNING: We will continue execution below!!!
     } else {
       state_ = ExceptionThrown;
       ++counts_thrown_;
       e << "The above exception was thrown while processing module "
         << brief_context(md_, p) << '\n';
       if (auto edmEx = dynamic_cast<Exception*>(&e)) {
         cached_exception_ = make_exception_ptr(*edmEx);
       } else {
         cached_exception_ =
           make_exception_ptr(Exception{errors::OtherArt, string(), e});
       }
       rethrow_exception(cached_exception_);
     }
   }
   catch (bad_alloc const& bda) {
     state_ = ExceptionThrown;
     ++counts_thrown_;
     auto art_ex =
       Exception{errors::BadAlloc}
       << "A bad_alloc exception occurred during a call to the module "
       << brief_context(md_, p) << '\n'
       << "The job has probably exhausted the virtual memory available to the "
          "process.\n";
     cached_exception_ = make_exception_ptr(art_ex);
     rethrow_exception(cached_exception_);
   }
   catch (exception const& e) {
     state_ = ExceptionThrown;
     ++counts_thrown_;
     auto art_ex = Exception{errors::StdException}
                   << "An exception occurred during a call to the module "
                   << brief_context(md_, p) << '\n'
                   << e.what();
     cached_exception_ = make_exception_ptr(art_ex);
     rethrow_exception(cached_exception_);
   }
   catch (string const& s) {
     state_ = ExceptionThrown;
     ++counts_thrown_;
     auto art_ex = Exception{errors::BadExceptionType, "string"}
                   << "A string thrown as an exception occurred during a call "
                      "to the module "
                   << brief_context(md_, p) << '\n'
                   << s << '\n';
     cached_exception_ = make_exception_ptr(art_ex);
     rethrow_exception(cached_exception_);
   }
   catch (char const* c) {
     state_ = ExceptionThrown;
     ++counts_thrown_;
     auto art_ex = Exception{errors::BadExceptionType, "char const*"}
                   << "A char const* thrown as an exception occurred during a "
                      "call to the module "
                   << brief_context(md_, p) << '\n'
                   << c << '\n';
     cached_exception_ = make_exception_ptr(art_ex);
     rethrow_exception(cached_exception_);
   }
   catch (...) {
     ++counts_thrown_;
     state_ = ExceptionThrown;
     auto art_ex = Exception{errors::Unknown, "repeated"}
                   << "An unknown occurred during a previous call to the module "
                   << brief_context(md_, p) << '\n';
     cached_exception_ = make_exception_ptr(art_ex);
     rethrow_exception(cached_exception_);
   }

void art::Worker::endJob ( )

inherited

Definition at line 207 of file Worker.cc.

References art::Worker::actReg_, art::Worker::doEndJob(), art::Worker::md_, art::ActivityRegistry::sPostModuleEndJob, and art::ActivityRegistry::sPreModuleEndJob.

       {
     actReg_.sPreModuleEndJob.invoke(md_);
     doEndJob();
     actReg_.sPostModuleEndJob.invoke(md_);
   }
   catch (...) {
     rethrow_with_context(std::current_exception(), md_, "endJob");
   }

bool art::Worker::isUnique ( ) const

inherited

Definition at line 592 of file Worker.cc.

References art::Worker::counts_visited_, art::Worker::doWork_event(), art::ScheduleID::first(), art::Worker::md_, art::ModuleDescription::moduleThreadingType(), art::replicated, art::Worker::runWorker(), art::ModuleContext::scheduleID(), art::Worker::scheduleID_, art::Worker::serialTaskQueueChain(), TDEBUG_BEGIN_FUNC_SI, TDEBUG_END_FUNC_SI, TDEBUG_FUNC_SI, art::Worker::waitingTasks_, and art::Worker::workStarted_.

   {
     if (scheduleID_ == ScheduleID::first()) {
       return true;
     }
     return md_.moduleThreadingType() == ModuleThreadingType::replicated;
   }

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

protectedinherited

Definition at line 127 of file Worker.cc.

References art::Worker::md_, and art::ModuleDescription::moduleLabel().

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

   {
     return md_.moduleLabel();
   }

void art::Worker::reset ( )

inherited

Definition at line 149 of file Worker.cc.

References art::Worker::cached_exception_, art::Worker::Ready, art::Worker::returnCode_, art::Worker::scheduleID_, art::Worker::state_, TDEBUG_FUNC_SI, art::Worker::waitingTasks_, and art::Worker::workStarted_.

   {
     state_ = Ready;
     cached_exception_ = std::exception_ptr{};
     TDEBUG_FUNC_SI(6, scheduleID_)
       << hex << this << dec << " Resetting waitingTasks_";
     waitingTasks_.reset();
     workStarted_ = false;
     returnCode_ = false;
   }

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

inherited

Definition at line 226 of file Worker.cc.

References art::Worker::actReg_, art::Worker::doRespondToCloseInputFile(), art::Worker::md_, art::ActivityRegistry::sPostModuleRespondToCloseInputFile, and art::ActivityRegistry::sPreModuleRespondToCloseInputFile.

   {
     actReg_.sPreModuleRespondToCloseInputFile.invoke(md_);
     doRespondToCloseInputFile(fb);
     actReg_.sPostModuleRespondToCloseInputFile.invoke(md_);
   }

void art::Worker::respondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 242 of file Worker.cc.

References art::Worker::actReg_, art::Worker::doRespondToCloseOutputFiles(), art::Worker::md_, art::ActivityRegistry::sPostModuleRespondToCloseOutputFiles, and art::ActivityRegistry::sPreModuleRespondToCloseOutputFiles.

   {
     actReg_.sPreModuleRespondToCloseOutputFiles.invoke(md_);
     doRespondToCloseOutputFiles(fb);
     actReg_.sPostModuleRespondToCloseOutputFiles.invoke(md_);
   }

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

inherited

Definition at line 218 of file Worker.cc.

References art::Worker::actReg_, art::Worker::doRespondToOpenInputFile(), art::Worker::md_, art::ActivityRegistry::sPostModuleRespondToOpenInputFile, and art::ActivityRegistry::sPreModuleRespondToOpenInputFile.

   {
     actReg_.sPreModuleRespondToOpenInputFile.invoke(md_);
     doRespondToOpenInputFile(fb);
     actReg_.sPostModuleRespondToOpenInputFile.invoke(md_);
   }

void art::Worker::respondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 234 of file Worker.cc.

References art::Worker::actReg_, art::Worker::doRespondToOpenOutputFiles(), art::Worker::md_, art::ActivityRegistry::sPostModuleRespondToOpenOutputFiles, and art::ActivityRegistry::sPreModuleRespondToOpenOutputFiles.

   {
     actReg_.sPreModuleRespondToOpenOutputFiles.invoke(md_);
     doRespondToOpenOutputFiles(fb);
     actReg_.sPostModuleRespondToOpenOutputFiles.invoke(md_);
   }

bool art::Worker::returnCode ( ) const

inherited

Definition at line 134 of file Worker.cc.

References art::Worker::returnCode_.

   {
     return returnCode_.load();
   }

void art::Worker::runWorker	(	EventPrincipal &	p,
		ModuleContext const &	mc
	)

inherited

Definition at line 466 of file Worker.cc.

References art::Worker::actions_, art::Worker::actReg_, art::errors::BadAlloc, art::errors::BadExceptionType, art::Worker::cached_exception_, art::Worker::counts_failed_, art::Worker::counts_passed_, art::Worker::counts_thrown_, art::Worker::doProcess(), art::Worker::ExceptionThrown, art::Worker::Fail, art::actions::FailModule, art::actions::FailPath, art::ActionTable::find(), art::actions::IgnoreCompletely, art::Worker::md_, art::ModuleContext::onEndPath(), art::errors::OtherArt, art::Worker::Pass, art::Worker::returnCode_, art::ModuleContext::scheduleID(), art::actions::SkipEvent, art::ActivityRegistry::sPostModule, art::ActivityRegistry::sPreModule, art::Worker::state_, art::errors::StdException, TDEBUG_BEGIN_TASK_SI, TDEBUG_END_TASK_SI, art::errors::Unknown, art::Worker::waitingTasks_, and art::Worker::Working.

Referenced by art::Worker::isUnique().

   {
     auto const sid = mc.scheduleID();
     TDEBUG_BEGIN_TASK_SI(4, sid);
     returnCode_ = false;
     try {
       // Transition from Ready state to Working state.
       state_ = Working;
       actReg_.sPreModule.invoke(mc);
       // Note: Only filters ever return false, and when they do it
       // means they have rejected.
       returnCode_ = doProcess(p, mc);
       actReg_.sPostModule.invoke(mc);
       state_ = Fail;
       if (returnCode_.load()) {
         state_ = Pass;
       }
     }
     catch (cet::exception& e) {
       auto action = actions_.find(e.root_cause());
       // If we are processing an endPath, treat SkipEvent or FailPath
       // as FailModule, so any subsequent OutputModules are still run.
       if (mc.onEndPath()) {
         if ((action == actions::SkipEvent) || (action == actions::FailPath)) {
           action = actions::FailModule;
         }
       }
       if (action == actions::IgnoreCompletely) {
         state_ = Pass;
         returnCode_ = true;
         ++counts_passed_;
         mf::LogWarning("IgnoreCompletely") << "Module ignored an exception\n"
                                            << e.what();
         // WARNING: We will continue execution below!!!
       } else if (action == actions::FailModule) {
         state_ = Fail;
         returnCode_ = true;
         ++counts_failed_;
         mf::LogWarning("FailModule") << "Module failed due to an exception\n"
                                      << e.what();
         // WARNING: We will continue execution below!!!
       } else {
         state_ = ExceptionThrown;
         ++counts_thrown_;
         e << "The above exception was thrown while processing module "
           << brief_context(md_, p);
         if (auto art_ex = dynamic_cast<Exception*>(&e)) {
           cached_exception_ = make_exception_ptr(*art_ex);
         } else {
           cached_exception_ =
             make_exception_ptr(Exception{errors::OtherArt, string(), e});
         }
         waitingTasks_.doneWaiting(cached_exception_);
         TDEBUG_END_TASK_SI(4, sid) << "because of EXCEPTION";
         return;
       }
     }
     catch (bad_alloc const& bda) {
       state_ = ExceptionThrown;
       ++counts_thrown_;
       auto art_ex =
         Exception{errors::BadAlloc}
         << "A bad_alloc exception was thrown while processing module "
         << brief_context(md_, p) << '\n'
         << "The job has probably exhausted the virtual memory available to the "
            "process.\n";
       cached_exception_ = make_exception_ptr(art_ex);
       waitingTasks_.doneWaiting(cached_exception_);
       TDEBUG_END_TASK_SI(4, sid) << "because of EXCEPTION";
       return;
     }
     catch (exception const& e) {
       state_ = ExceptionThrown;
       ++counts_thrown_;
       auto art_ex = Exception{errors::StdException}
                     << "An exception was thrown while processing module "
                     << brief_context(md_, p) << '\n'
                     << e.what();
       cached_exception_ = make_exception_ptr(art_ex);
       waitingTasks_.doneWaiting(cached_exception_);
       TDEBUG_END_TASK_SI(4, sid) << "because of EXCEPTION";
       return;
     }
     catch (string const& s) {
       state_ = ExceptionThrown;
       ++counts_thrown_;
       auto art_ex =
         Exception{errors::BadExceptionType, "string"}
         << "A string was thrown as an exception while processing module "
         << brief_context(md_, p) << '\n'
         << s << '\n';
       cached_exception_ = make_exception_ptr(art_ex);
       waitingTasks_.doneWaiting(cached_exception_);
       TDEBUG_END_TASK_SI(4, sid) << "because of EXCEPTION";
       return;
     }
     catch (char const* c) {
       state_ = ExceptionThrown;
       ++counts_thrown_;
       auto art_ex =
         Exception{errors::BadExceptionType, "char const*"}
         << "A char const* was thrown as an exception while processing module "
         << brief_context(md_, p) << '\n'
         << c << '\n';
       cached_exception_ = make_exception_ptr(art_ex);
       waitingTasks_.doneWaiting(cached_exception_);
       TDEBUG_END_TASK_SI(4, sid) << "because of EXCEPTION";
       return;
     }
     catch (...) {
       ++counts_thrown_;
       state_ = ExceptionThrown;
       auto art_ex =
         Exception{errors::Unknown, "repeated"}
         << "An unknown exception was thrown while processing module "
         << brief_context(md_, p) << '\n';
       cached_exception_ = make_exception_ptr(art_ex);
       waitingTasks_.doneWaiting(cached_exception_);
       TDEBUG_END_TASK_SI(4, sid) << "because of EXCEPTION";
       return;
     }
     waitingTasks_.doneWaiting(exception_ptr{});
     TDEBUG_END_TASK_SI(4, sid);
   }

ScheduleID art::Worker::scheduleID ( ) const

inlineinherited

Definition at line 70 of file Worker.h.

     {
       return scheduleID_;
     }

SerialTaskQueueChain * art::Worker::serialTaskQueueChain ( ) const

inherited

Definition at line 140 of file Worker.cc.

References art::Worker::doSerialTaskQueueChain().

Referenced by art::Worker::isUnique().

   {
     return doSerialTaskQueueChain();
   }

size_t art::Worker::timesExcept ( ) const

inherited

Definition at line 190 of file Worker.cc.

References art::Worker::counts_thrown_.

   {
     return counts_thrown_.load();
   }

size_t art::Worker::timesFailed ( ) const

inherited

Definition at line 183 of file Worker.cc.

References art::Worker::counts_failed_.

   {
     return counts_failed_.load();
   }

size_t art::Worker::timesPassed ( ) const

inherited

Definition at line 176 of file Worker.cc.

References art::Worker::counts_passed_.

   {
     return counts_passed_.load();
   }

size_t art::Worker::timesRun ( ) const

inherited

Definition at line 169 of file Worker.cc.

References art::Worker::counts_run_.

   {
     return counts_run_.load();
   }

size_t art::Worker::timesVisited ( ) const

inherited

Definition at line 162 of file Worker.cc.

References art::Worker::counts_visited_.

   {
     return counts_visited_.load();
   }

Member Data Documentation

std::atomic<std::size_t> art::Worker::counts_failed_ {}

protectedinherited

Definition at line 101 of file Worker.h.

Referenced by art::WorkerT< T >::doProcess(), art::OutputWorker::doProcess(), art::Worker::doWork_event(), art::Worker::runWorker(), and art::Worker::timesFailed().

std::atomic<std::size_t> art::Worker::counts_passed_ {}

protectedinherited

Definition at line 100 of file Worker.h.

Referenced by art::WorkerT< T >::doProcess(), art::OutputWorker::doProcess(), art::Worker::doWork_event(), art::Worker::runWorker(), and art::Worker::timesPassed().

std::atomic<std::size_t> art::Worker::counts_run_ {}

protectedinherited

Definition at line 99 of file Worker.h.

Referenced by art::WorkerT< T >::doProcess(), art::OutputWorker::doProcess(), and art::Worker::timesRun().

std::atomic<std::size_t> art::Worker::counts_thrown_ {}

protectedinherited

Definition at line 102 of file Worker.h.

Referenced by art::Worker::doWork_event(), art::Worker::runWorker(), and art::Worker::timesExcept().

std::atomic<std::size_t> art::Worker::counts_visited_ {}

protectedinherited

Definition at line 98 of file Worker.h.

Referenced by art::Worker::doWork_event(), art::Worker::isUnique(), and art::Worker::timesVisited().

template<typename T >

cet::exempt_ptr<T> art::WorkerT< T >::module_

private

Definition at line 41 of file WorkerT.h.

Referenced by art::WorkerT< T >::doBegin(), art::WorkerT< T >::doBeginJob(), art::WorkerT< T >::doEnd(), art::WorkerT< T >::doEndJob(), art::WorkerT< T >::doProcess(), art::WorkerT< T >::doRespondToCloseInputFile(), art::WorkerT< T >::doRespondToCloseOutputFiles(), art::WorkerT< T >::doRespondToOpenInputFile(), art::WorkerT< T >::doRespondToOpenOutputFiles(), art::WorkerT< T >::doSerialTaskQueueChain(), and art::WorkerT< T >::WorkerT().

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

art/Framework/Core/WorkerT.h

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

template<typename T> class art::WorkerT< T >

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T>
class art::WorkerT< T >