#include "TriggerPathsExecutor.h"

Classes
class	PathsDoneTask

Public Member Functions
	TriggerPathsExecutor (ScheduleID, PathManager &, ActionTable const &, ActivityRegistry const &activityRegistry, GlobalTaskGroup &group)

	TriggerPathsExecutor (TriggerPathsExecutor const &)=delete

	TriggerPathsExecutor (TriggerPathsExecutor &&)=delete

TriggerPathsExecutor &	operator= (TriggerPathsExecutor const &)=delete

TriggerPathsExecutor &	operator= (TriggerPathsExecutor &&)=delete

void	process (Transition, Principal &)

void	process_event (hep::concurrency::WaitingTaskPtr endPathTask, EventPrincipal &)

void	beginJob (detail::SharedResources const &resources)

void	endJob ()

void	respondToOpenInputFile (FileBlock const &)

void	respondToCloseInputFile (FileBlock const &)

void	respondToOpenOutputFiles (FileBlock const &)

void	respondToCloseOutputFiles (FileBlock const &)

void	process_event_paths_done (EventPrincipal &)

Private Member Functions
bool	skipNonReplicated_ (Worker const &)

Private Attributes
ScheduleContext const	sc_

ActionTable const &	actionTable_

ActivityRegistry const &	actReg_

PathsInfo &	triggerPathsInfo_

std::unique_ptr< Worker >	results_inserter_

GlobalTaskGroup &	taskGroup_

Detailed Description

Definition at line 43 of file TriggerPathsExecutor.h.

Constructor & Destructor Documentation

art::TriggerPathsExecutor::TriggerPathsExecutor	(	ScheduleID	scheduleID,
		PathManager &	pm,
		ActionTable const &	actions,
		ActivityRegistry const &	activityRegistry,
		GlobalTaskGroup &	group
	)

Definition at line 40 of file TriggerPathsExecutor.cc.

References actionTable_, actReg_, results_inserter_, taskGroup_, TDEBUG_FUNC_SI, and triggerPathsInfo_.

     : sc_{scheduleID}
     , actionTable_{actions}
     , actReg_{activityRegistry}
     , triggerPathsInfo_{pm.triggerPathsInfo(scheduleID)}
     , results_inserter_{pm.releaseTriggerResultsInserter(scheduleID)}
     , taskGroup_{group}
   {
     TDEBUG_FUNC_SI(5, scheduleID) << hex << this << dec;
   }

art::TriggerPathsExecutor::TriggerPathsExecutor ( TriggerPathsExecutor const & )

delete

art::TriggerPathsExecutor::TriggerPathsExecutor ( TriggerPathsExecutor && )

delete

Member Function Documentation

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

Definition at line 57 of file TriggerPathsExecutor.cc.

References results_inserter_, and triggerPathsInfo_.

Referenced by art::Schedule::beginJob().

   {
     for (auto& worker : unique_workers(triggerPathsInfo_)) {
       worker.beginJob(resources);
     }
     if (results_inserter_) {
       results_inserter_->beginJob(resources);
     }
   }

void art::TriggerPathsExecutor::endJob ( )

Definition at line 68 of file TriggerPathsExecutor.cc.

References e, art::errors::EndJobFailure, results_inserter_, and triggerPathsInfo_.

Referenced by art::Schedule::endJob().

   {
     Exception error{errors::EndJobFailure};
     for (auto& worker : unique_workers(triggerPathsInfo_)) {
       // FIXME: The catch and rethrow here seems to have little value added.
       try {
         worker.endJob();
       }
       catch (cet::exception& e) {
         error << "cet::exception caught in TriggerPathsExecutor::endJob\n"
               << e.explain_self();
         throw error;
       }
       catch (exception& e) {
         error << "Standard library exception caught in "
                  "TriggerPathsExecutor::endJob\n"
               << e.what();
         throw error;
       }
       catch (...) {
         error << "Unknown exception caught in TriggerPathsExecutor::endJob\n";
         throw error;
       }
     }
     if (results_inserter_) {
       // FIXME: The catch and rethrow here seems to have little value added.
       try {
         results_inserter_->endJob();
       }
       catch (cet::exception& e) {
         error << "cet::exception caught in TriggerPathsExecutor::endJob\n"
               << e.explain_self();
         throw error;
       }
       catch (exception& e) {
         error << "Standard library exception caught in "
                  "TriggerPathsExecutor::endJob\n"
               << e.what();
         throw error;
       }
       catch (...) {
         error << "Unknown exception caught in TriggerPathsExecutor::endJob\n";
         throw error;
       }
     }
   }

TriggerPathsExecutor& art::TriggerPathsExecutor::operator= ( TriggerPathsExecutor const & )

delete

TriggerPathsExecutor& art::TriggerPathsExecutor::operator= ( TriggerPathsExecutor && )

delete

void art::TriggerPathsExecutor::process	(	Transition	trans,
		Principal &	principal
	)

Definition at line 160 of file TriggerPathsExecutor.cc.

References art::PathsInfo::paths(), art::PathsInfo::reset(), and triggerPathsInfo_.

Referenced by art::Schedule::process().

   {
     triggerPathsInfo_.reset();
     for (auto& path : triggerPathsInfo_.paths()) {
       path.process(trans, principal);
     }
   }

void art::TriggerPathsExecutor::process_event	(	hep::concurrency::WaitingTaskPtr	endPathTask,
		EventPrincipal &
	)

Definition at line 213 of file TriggerPathsExecutor.cc.

References actReg_, art::ScheduleContext::id(), art::PathsInfo::incrementTotalEventCount(), art::ModuleContext::invalid(), art::EventPrincipal::makeEvent(), art::GlobalTaskGroup::may_run(), art::PathsInfo::paths(), art::PathsInfo::reset_for_event(), results_inserter_, sc_, art::ActivityRegistry::sPreProcessEvent, taskGroup_, TDEBUG_BEGIN_FUNC_SI, TDEBUG_END_FUNC_SI, and triggerPathsInfo_.

Referenced by art::Schedule::process_event_modifiers().

   {
     // We get here as part of the readAndProcessEventTask (schedule
     // head task).
     actReg_.sPreProcessEvent.invoke(
       event_principal.makeEvent(ModuleContext::invalid()), sc_);
     auto const scheduleID = sc_.id();
     TDEBUG_BEGIN_FUNC_SI(4, scheduleID);
     if (results_inserter_) {
       results_inserter_->reset();
     }
     triggerPathsInfo_.reset_for_event();
     triggerPathsInfo_.incrementTotalEventCount();
     try {
       if (triggerPathsInfo_.paths().empty()) {
         auto pathsDoneTask = make_waiting_task<PathsDoneTask>(
           this, endPathTask, event_principal, taskGroup_);
         taskGroup_.may_run(pathsDoneTask);
         TDEBUG_END_FUNC_SI(4, scheduleID);
         return;
       }
       auto pathsDoneTask = std::make_shared<WaitingTask>(
         PathsDoneTask{this, endPathTask, event_principal, taskGroup_},
         triggerPathsInfo_.paths().size());
       for (auto& path : triggerPathsInfo_.paths()) {
         // Start each path running.  The path will start a spawn chain
         // going to run each worker in the order specified on the
         // path, and when they have all been run, it will call
         // doneWaiting() on the pathsDoneTask, which decrements its
         // reference count, which will eventually cause it to run when
         // every path has finished.
         path.process(pathsDoneTask, event_principal);
       }
       TDEBUG_END_FUNC_SI(4, scheduleID);
     }
     catch (...) {
       taskGroup_.may_run(endPathTask, current_exception());
       TDEBUG_END_FUNC_SI(4, scheduleID) << "because of EXCEPTION";
     }
   }

void art::TriggerPathsExecutor::process_event_paths_done ( EventPrincipal & principal )

Definition at line 256 of file TriggerPathsExecutor.cc.

References art::HLTGlobalStatus::accept(), actionTable_, art::PathContext::art_path_spec(), e, art::actions::FailModule, art::actions::FailPath, art::ActionTable::find(), art::ScheduleContext::id(), art::actions::IgnoreCompletely, art::PathsInfo::incrementPassedEventCount(), art::PathsInfo::pathResults(), results_inserter_, sc_, art::actions::SkipEvent, TDEBUG_BEGIN_FUNC_SI, TDEBUG_END_FUNC_SI, and triggerPathsInfo_.

   {
     // We come here as part of the pathsDoneTask.
     auto const scheduleID = sc_.id();
     TDEBUG_BEGIN_FUNC_SI(4, scheduleID);
     try {
       if (triggerPathsInfo_.pathResults().accept()) {
         triggerPathsInfo_.incrementPassedEventCount();
       }
       if (results_inserter_) {
         // FIXME: not sure what the trigger bit should be
         auto const& resultsInserterDesc = results_inserter_->description();
         PathContext const pc{sc_,
                              PathContext::art_path_spec(),
                              {resultsInserterDesc.moduleLabel()}};
         ModuleContext const mc{pc, resultsInserterDesc};
         results_inserter_->doWork_event(principal, mc);
       }
     }
     catch (cet::exception& e) {
       auto action = actionTable_.find(e.root_cause());
       assert(action != actions::IgnoreCompletely);
       assert(action != actions::FailPath);
       assert(action != actions::FailModule);
       if (action != actions::SkipEvent) {
         TDEBUG_END_FUNC_SI(4, scheduleID);
         throw;
       }
       mf::LogWarning(e.category())
         << "An exception occurred inserting the TriggerResults object:\n"
         << cet::trim_right_copy(e.what(), " \n");
     }
     TDEBUG_END_FUNC_SI(4, scheduleID);
   }

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

Definition at line 127 of file TriggerPathsExecutor.cc.

References results_inserter_, and triggerPathsInfo_.

Referenced by art::Schedule::respondToCloseInputFile().

   {
     for (auto& worker : unique_workers(triggerPathsInfo_)) {
       worker.respondToCloseInputFile(fb);
     }
     if (results_inserter_) {
       results_inserter_->respondToCloseInputFile(fb);
     }
   }

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

Definition at line 149 of file TriggerPathsExecutor.cc.

References results_inserter_, and triggerPathsInfo_.

Referenced by art::Schedule::respondToCloseOutputFiles().

   {
     for (auto& worker : unique_workers(triggerPathsInfo_)) {
       worker.respondToCloseOutputFiles(fb);
     }
     if (results_inserter_) {
       results_inserter_->respondToCloseOutputFiles(fb);
     }
   }

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

Definition at line 116 of file TriggerPathsExecutor.cc.

References results_inserter_, and triggerPathsInfo_.

Referenced by art::Schedule::respondToOpenInputFile().

   {
     for (auto& worker : unique_workers(triggerPathsInfo_)) {
       worker.respondToOpenInputFile(fb);
     }
     if (results_inserter_) {
       results_inserter_->respondToOpenInputFile(fb);
     }
   }

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

Definition at line 138 of file TriggerPathsExecutor.cc.

References results_inserter_, and triggerPathsInfo_.

Referenced by art::Schedule::respondToOpenOutputFiles().

   {
     for (auto& worker : unique_workers(triggerPathsInfo_)) {
       worker.respondToOpenOutputFiles(fb);
     }
     if (results_inserter_) {
       results_inserter_->respondToOpenOutputFiles(fb);
     }
   }