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 ()=default
	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)
bool	doWork (Transition, Principal &, ModuleContext const &)
void	doWork_event (hep::concurrency::WaitingTaskPtr workerInPathDoneTask, EventPrincipal &, ModuleContext const &)
void	doWork_event (EventPrincipal &, ModuleContext const &)
ScheduleID	scheduleID () const
ModuleDescription const &	description () const
std::string const &	label () const
bool	returnCode () 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 &)

Protected Member Functions
virtual std::string	workerType () const =0
virtual hep::concurrency::SerialTaskQueueChain *	implSerialTaskQueueChain () const =0
virtual void	implBeginJob (detail::SharedResources const &resources)=0
virtual void	implEndJob ()=0
virtual bool	implDoBegin (RunPrincipal &rp, ModuleContext const &mc)=0
virtual bool	implDoEnd (RunPrincipal &rp, ModuleContext const &mc)=0
virtual bool	implDoBegin (SubRunPrincipal &srp, ModuleContext const &mc)=0
virtual bool	implDoEnd (SubRunPrincipal &srp, ModuleContext const &mc)=0
virtual bool	implDoProcess (EventPrincipal &, ModuleContext const &)=0

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 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
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_

Friends
class	RunWorkerFunctor

Detailed Description

Definition at line 50 of file Worker.h.

Member Enumeration Documentation

enum art::Worker::State

Enumerator
Ready
Pass
Fail
Working
ExceptionThrown

Definition at line 54 of file Worker.h.

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

Constructor & Destructor Documentation

virtual art::Worker::~Worker ( )

virtualdefault

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

Definition at line 105 of file Worker.cc.

    : 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 193 of file Worker.cc.

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

ModuleDescription const & art::Worker::description

(

)

const

Definition at line 118 of file Worker.cc.

  {
    return md_;
  }

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

Definition at line 245 of file Worker.cc.

  {
    switch (state_.load()) {
    case Ready:
      break;
    case Pass:
      return true;
    case Fail:
      return false;
    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.\n";
      rethrow_exception(cached_exception_);
    }
    case Working:
      break; // See below.
    }
    bool rc = false;
    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 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";
      }
      state_ = Working;
      if (trans == Transition::BeginRun) {
        actReg_.sPreModuleBeginRun.invoke(mc);
        rc = implDoBegin(dynamic_cast<RunPrincipal&>(principal), mc);
        actReg_.sPostModuleBeginRun.invoke(mc);
      } else if (trans == Transition::EndRun) {
        actReg_.sPreModuleEndRun.invoke(mc);
        rc = implDoEnd(dynamic_cast<RunPrincipal&>(principal), mc);
        actReg_.sPostModuleEndRun.invoke(mc);
      } else if (trans == Transition::BeginSubRun) {
        actReg_.sPreModuleBeginSubRun.invoke(mc);
        rc = implDoBegin(dynamic_cast<SubRunPrincipal&>(principal), mc);
        actReg_.sPostModuleBeginSubRun.invoke(mc);
      } else if (trans == Transition::EndSubRun) {
        actReg_.sPreModuleEndSubRun.invoke(mc);
        rc = implDoEnd(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<art::Exception*>(&e)) {
        cached_exception_ = std::make_exception_ptr(*edmEx);
      } else {
        auto art_ex = art::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_);
    }
    return rc;
  }

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

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

Definition at line 363 of file Worker.cc.

                                                                     {
    ++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_ = implDoProcess(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() << "\n";
      // 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() << "\n";
      // 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 203 of file Worker.cc.

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

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

protectedpure virtual

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

virtual bool art::Worker::implDoBegin ( RunPrincipal &  rp, ModuleContext const &  mc  )

protectedpure virtual

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

virtual bool art::Worker::implDoBegin ( SubRunPrincipal &  srp, ModuleContext const &  mc  )

protectedpure virtual

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

virtual bool art::Worker::implDoEnd ( RunPrincipal &  rp, ModuleContext const &  mc  )

protectedpure virtual

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

virtual bool art::Worker::implDoEnd ( SubRunPrincipal &  srp, ModuleContext const &  mc  )

protectedpure virtual

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

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

protectedpure virtual

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

virtual void art::Worker::implEndJob ( )

protectedpure virtual

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

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

privatepure virtual

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

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

privatepure virtual

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

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

privatepure virtual

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

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

privatepure virtual

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

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

protectedpure virtual

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

string const & art::Worker::label

(

)

const

Definition at line 124 of file Worker.cc.

  {
    return md_.moduleLabel();
  }

void art::Worker::reset

(

)

Definition at line 146 of file Worker.cc.

  {
    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 221 of file Worker.cc.

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

void art::Worker::respondToCloseOutputFiles

(

FileBlock const &

fb

)

Definition at line 237 of file Worker.cc.

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

void art::Worker::respondToOpenInputFile

(

FileBlock const &

fb

)

Definition at line 213 of file Worker.cc.

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

void art::Worker::respondToOpenOutputFiles

(

FileBlock const &

fb

)

Definition at line 229 of file Worker.cc.

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

bool art::Worker::returnCode

(

)

const

Definition at line 131 of file Worker.cc.

  {
    return returnCode_.load();
  }

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

Definition at line 462 of file Worker.cc.

  {
    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_ = implDoProcess(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() << "\n";
        // 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() << "\n";
        // 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 75 of file Worker.h.

    {
      return scheduleID_;
    }

SerialTaskQueueChain * art::Worker::serialTaskQueueChain

(

)

const

Definition at line 137 of file Worker.cc.

  {
    return implSerialTaskQueueChain();
  }

size_t art::Worker::timesExcept

(

)

const

Definition at line 187 of file Worker.cc.

  {
    return counts_thrown_.load();
  }

size_t art::Worker::timesFailed

(

)

const

Definition at line 180 of file Worker.cc.

  {
    return counts_failed_.load();
  }

size_t art::Worker::timesPassed

(

)

const

Definition at line 173 of file Worker.cc.

  {
    return counts_passed_.load();
  }

size_t art::Worker::timesRun

(

)

const

Definition at line 166 of file Worker.cc.

  {
    return counts_run_.load();
  }

size_t art::Worker::timesVisited

(

)

const

Definition at line 159 of file Worker.cc.

  {
    return counts_visited_.load();
  }

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

protectedpure virtual

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

Friends And Related Function Documentation

friend class RunWorkerFunctor

friend

Definition at line 51 of file Worker.h.

Member Data Documentation

ActionTable const& art::Worker::actions_

private

Definition at line 122 of file Worker.h.

ActivityRegistry const& art::Worker::actReg_

private

Definition at line 123 of file Worker.h.

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

private

Definition at line 134 of file Worker.h.

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

protected

Definition at line 149 of file Worker.h.

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

protected

Definition at line 148 of file Worker.h.

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

protected

Definition at line 147 of file Worker.h.

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

protected

Definition at line 150 of file Worker.h.

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

protected

Definition at line 146 of file Worker.h.

ModuleDescription const art::Worker::md_

private

Definition at line 121 of file Worker.h.

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

private

Definition at line 137 of file Worker.h.

ScheduleID const art::Worker::scheduleID_

private

Definition at line 120 of file Worker.h.

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

private

Definition at line 124 of file Worker.h.

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

private

Definition at line 143 of file Worker.h.

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

private

Definition at line 136 of file Worker.h.

---

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

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