art::Worker Class Reference

#include "Worker.h"

Inheritance diagram for art::Worker:

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

Public Member Functions
virtual	~Worker ()
	Worker (ModuleDescription const &, 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
virtual hep::concurrency::SerialTaskQueueChain *	doSerialTaskQueueChain () const =0
virtual void	doBeginJob (detail::SharedResources const &resources)=0
virtual void	doEndJob ()=0
virtual void	doBegin (RunPrincipal &rp, ModuleContext const &mc)=0
virtual void	doEnd (RunPrincipal &rp, ModuleContext const &mc)=0
virtual void	doBegin (SubRunPrincipal &srp, ModuleContext const &mc)=0
virtual void	doEnd (SubRunPrincipal &srp, ModuleContext const &mc)=0
virtual bool	doProcess (EventPrincipal &, ModuleContext const &)=0
virtual void	doRespondToOpenInputFile (FileBlock const &fb)=0
virtual void	doRespondToCloseInputFile (FileBlock const &fb)=0
virtual void	doRespondToOpenOutputFiles (FileBlock const &fb)=0
virtual void	doRespondToCloseOutputFiles (FileBlock const &fb)=0

Private Attributes
ScheduleID const	scheduleID_
ModuleDescription const	md_
ActionTable const &	actions_
ActivityRegistry const &	actReg_
std::atomic< int >	state_ {Ready}
std::exception_ptr	cached_exception_ {}
std::atomic< bool >	workStarted_ {false}
std::atomic< bool >	returnCode_ {false}
hep::concurrency::WaitingTaskList	waitingTasks_

Detailed Description

Definition at line 47 of file Worker.h.

Member Enumeration Documentation

enum art::Worker::State

Enumerator
Ready
Pass
Fail
Working
ExceptionThrown

Definition at line 49 of file Worker.h.

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

Constructor & Destructor Documentation

art::Worker::~Worker ( )

virtualdefault

art::Worker::Worker	(	ModuleDescription const &	md,
		WorkerParams const &	wp
	)

Definition at line 108 of file Worker.cc.

References actions_, actReg_, md_, art::ModuleDescription::moduleLabel(), art::ModuleDescription::moduleName(), art::WorkerParams::scheduleID_, TDEBUG_FUNC_SI, and waitingTasks_.

    : scheduleID_{wp.scheduleID_}
    , md_{md}
    , actions_{wp.actions_}
    , actReg_{wp.actReg_}
    , waitingTasks_{wp.taskGroup_}
  {
    TDEBUG_FUNC_SI(5, wp.scheduleID_)
      << hex << this << dec << " name: " << md.moduleName()
      << " label: " << md.moduleLabel();
  }

Member Function Documentation

void art::Worker::beginJob

(

detail::SharedResources const &

resources

)

Definition at line 196 of file Worker.cc.

References actReg_, doBeginJob(), 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

Definition at line 121 of file Worker.cc.

References md_.

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

  {
    return md_;
  }

virtual void art::Worker::doBegin ( RunPrincipal &  rp, ModuleContext const &  mc  )

privatepure virtual

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

Referenced by doWork().

virtual void art::Worker::doBegin ( SubRunPrincipal &  srp, ModuleContext const &  mc  )

privatepure virtual

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

virtual void art::Worker::doBeginJob ( detail::SharedResources const &  resources )

privatepure virtual

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

Referenced by beginJob().

virtual void art::Worker::doEnd ( RunPrincipal &  rp, ModuleContext const &  mc  )

privatepure virtual

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

Referenced by doWork().

virtual void art::Worker::doEnd ( SubRunPrincipal &  srp, ModuleContext const &  mc  )

privatepure virtual

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

virtual void art::Worker::doEndJob ( )

privatepure virtual

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

Referenced by endJob().

virtual bool art::Worker::doProcess ( EventPrincipal &  , ModuleContext const &    )

privatepure virtual

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

Referenced by doWork_event(), and runWorker().

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

privatepure virtual

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

Referenced by respondToCloseInputFile().

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

privatepure virtual

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

Referenced by respondToCloseOutputFiles().

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

privatepure virtual

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

Referenced by respondToOpenInputFile().

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

privatepure virtual

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

Referenced by respondToOpenOutputFiles().

virtual hep::concurrency::SerialTaskQueueChain* art::Worker::doSerialTaskQueueChain ( ) const

privatepure virtual

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

Referenced by serialTaskQueueChain().

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

Definition at line 250 of file Worker.cc.

References actReg_, art::errors::BadAlloc, art::errors::BadExceptionType, art::BeginRun, art::BeginSubRun, cached_exception_, doBegin(), doEnd(), art::EndRun, art::EndSubRun, ExceptionThrown, Fail, md_, art::errors::OtherArt, Pass, 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, state_, art::errors::StdException, art::errors::Unknown, and 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 &
	)

Referenced by isUnique().

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

Definition at line 366 of file Worker.cc.

References actions_, actReg_, art::errors::BadAlloc, art::errors::BadExceptionType, cached_exception_, counts_failed_, counts_passed_, counts_thrown_, counts_visited_, doProcess(), ExceptionThrown, Fail, art::actions::FailModule, art::ActionTable::find(), art::actions::IgnoreCompletely, md_, art::errors::OtherArt, Pass, returnCode_, art::ActivityRegistry::sPostModule, art::ActivityRegistry::sPreModule, state_, art::errors::StdException, art::errors::Unknown, and 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

(

)

Definition at line 207 of file Worker.cc.

References actReg_, doEndJob(), 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

Definition at line 592 of file Worker.cc.

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

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

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

protected

Definition at line 127 of file Worker.cc.

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

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

  {
    return md_.moduleLabel();
  }

void art::Worker::reset

(

)

Definition at line 149 of file Worker.cc.

References cached_exception_, Ready, returnCode_, scheduleID_, state_, TDEBUG_FUNC_SI, waitingTasks_, and 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

)

Definition at line 226 of file Worker.cc.

References actReg_, doRespondToCloseInputFile(), 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

)

Definition at line 242 of file Worker.cc.

References actReg_, doRespondToCloseOutputFiles(), 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

)

Definition at line 218 of file Worker.cc.

References actReg_, doRespondToOpenInputFile(), 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

)

Definition at line 234 of file Worker.cc.

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

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

bool art::Worker::returnCode

(

)

const

Definition at line 134 of file Worker.cc.

References returnCode_.

  {
    return returnCode_.load();
  }

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

Definition at line 466 of file Worker.cc.

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

Referenced by 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

inline

Definition at line 70 of file Worker.h.

    {
      return scheduleID_;
    }

SerialTaskQueueChain * art::Worker::serialTaskQueueChain

(

)

const

Definition at line 140 of file Worker.cc.

References doSerialTaskQueueChain().

Referenced by isUnique().

  {
    return doSerialTaskQueueChain();
  }

size_t art::Worker::timesExcept

(

)

const

Definition at line 190 of file Worker.cc.

References counts_thrown_.

  {
    return counts_thrown_.load();
  }

size_t art::Worker::timesFailed

(

)

const

Definition at line 183 of file Worker.cc.

References counts_failed_.

  {
    return counts_failed_.load();
  }

size_t art::Worker::timesPassed

(

)

const

Definition at line 176 of file Worker.cc.

References counts_passed_.

  {
    return counts_passed_.load();
  }

size_t art::Worker::timesRun

(

)

const

Definition at line 169 of file Worker.cc.

References counts_run_.

  {
    return counts_run_.load();
  }

size_t art::Worker::timesVisited

(

)

const

Definition at line 162 of file Worker.cc.

References counts_visited_.

  {
    return counts_visited_.load();
  }

Member Data Documentation

ActionTable const& art::Worker::actions_

private

Definition at line 122 of file Worker.h.

Referenced by doWork_event(), runWorker(), and Worker().

ActivityRegistry const& art::Worker::actReg_

private

Definition at line 123 of file Worker.h.

Referenced by beginJob(), doWork(), doWork_event(), endJob(), respondToCloseInputFile(), respondToCloseOutputFiles(), respondToOpenInputFile(), respondToOpenOutputFiles(), runWorker(), and Worker().

std::exception_ptr art::Worker::cached_exception_ {}

private

Definition at line 134 of file Worker.h.

Referenced by doWork(), doWork_event(), reset(), and runWorker().

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

protected

Definition at line 101 of file Worker.h.

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

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

protected

Definition at line 100 of file Worker.h.

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

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

protected

Definition at line 99 of file Worker.h.

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

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

protected

Definition at line 102 of file Worker.h.

Referenced by doWork_event(), runWorker(), and timesExcept().

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

protected

Definition at line 98 of file Worker.h.

Referenced by doWork_event(), isUnique(), and timesVisited().

ModuleDescription const art::Worker::md_

private

Definition at line 121 of file Worker.h.

Referenced by beginJob(), description(), doWork(), doWork_event(), endJob(), isUnique(), label(), respondToCloseInputFile(), respondToCloseOutputFiles(), respondToOpenInputFile(), respondToOpenOutputFiles(), runWorker(), and Worker().

std::atomic<bool> art::Worker::returnCode_ {false}

private

Definition at line 137 of file Worker.h.

Referenced by doWork_event(), reset(), returnCode(), and runWorker().

ScheduleID const art::Worker::scheduleID_

private

Definition at line 120 of file Worker.h.

Referenced by isUnique(), and reset().

std::atomic<int> art::Worker::state_ {Ready}

private

Definition at line 124 of file Worker.h.

Referenced by doWork(), doWork_event(), reset(), and runWorker().

hep::concurrency::WaitingTaskList art::Worker::waitingTasks_

private

Definition at line 143 of file Worker.h.

Referenced by isUnique(), reset(), runWorker(), and Worker().

std::atomic<bool> art::Worker::workStarted_ {false}

private

Definition at line 136 of file Worker.h.

Referenced by isUnique(), and reset().

---

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

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