#include <Schedule.h>

Public Types
typedef std::vector < edm::propagate_const < std::shared_ptr < OutputModuleCommunicator > > >	AllOutputModuleCommunicators

typedef std::vector< Worker * >	AllWorkers

typedef std::vector< std::string >	vstring

typedef std::vector< Worker * >	Workers

Public Member Functions
AllWorkers const &	allWorkers () const
	returns the collection of pointers to workers More...

void	availablePaths (std::vector< std::string > &oLabelsToFill) const
	adds to oLabelsToFill the labels for all paths in the process More...

void	beginJob (ProductRegistry const &, eventsetup::ESRecordsToProxyIndices const &, ProcessBlockHelperBase const &)

void	beginStream (unsigned int)

bool	changeModule (std::string const &iLabel, ParameterSet const &iPSet, const ProductRegistry &iRegistry, eventsetup::ESRecordsToProxyIndices const &)

void	clearCounters ()
	Clear all the counters in the trigger report. More...

void	closeOutputFiles ()

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

void	deleteModule (std::string const &iLabel, ActivityRegistry *areg)
	Deletes module with label iLabel. More...

void	endJob (ExceptionCollector &collector)

void	endPaths (std::vector< std::string > &oLabelsToFill) const
	adds to oLabelsToFill the labels for all end paths in the process More...

void	endStream (unsigned int)

void	fillModuleAndConsumesInfo (std::vector< ModuleDescription const * > &allModuleDescriptions, std::vector< std::pair< unsigned int, unsigned int >> &moduleIDToIndex, std::array< std::vector< std::vector< ModuleDescription const * >>, NumBranchTypes > &modulesWhoseProductsAreConsumedBy, std::vector< std::vector< ModuleProcessName >> &modulesInPreviousProcessesWhoseProductsAreConsumedBy, ProductRegistry const &preg) const

std::vector< ModuleDescription const * >	getAllModuleDescriptions () const

void	getTriggerReport (TriggerReport &rep) const

void	getTriggerTimingReport (TriggerTimingReport &rep) const

void	initializeEarlyDelete (std::vector< std::string > const &branchesToDeleteEarly, edm::ProductRegistry const &preg)

void	moduleDescriptionsInEndPath (std::string const &iEndPathLabel, std::vector< ModuleDescription const * > &descriptions, unsigned int hint) const

void	moduleDescriptionsInPath (std::string const &iPathLabel, std::vector< ModuleDescription const * > &descriptions, unsigned int hint) const

void	modulesInPath (std::string const &iPathLabel, std::vector< std::string > &oLabelsToFill) const
	adds to oLabelsToFill in execution order the labels of all modules in path iPathLabel More...

void	openOutputFiles (FileBlock &fb)

void	processOneEventAsync (WaitingTaskHolder iTask, unsigned int iStreamID, EventTransitionInfo &, ServiceToken const &token)

template<typename T >
void	processOneGlobalAsync (WaitingTaskHolder iTask, typename T::TransitionInfoType &transitionInfo, ServiceToken const &token, bool cleaningUpAfterException=false)

template<typename T >
void	processOneStreamAsync (WaitingTaskHolder iTask, unsigned int iStreamID, typename T::TransitionInfoType &transitionInfo, ServiceToken const &token, bool cleaningUpAfterException=false)

void	respondToCloseInputFile (FileBlock const &fb)

void	respondToOpenInputFile (FileBlock const &fb)

	Schedule (ParameterSet &proc_pset, service::TriggerNamesService const &tns, ProductRegistry &pregistry, BranchIDListHelper &branchIDListHelper, ProcessBlockHelperBase &, ThinnedAssociationsHelper &thinnedAssociationsHelper, SubProcessParentageHelper const subProcessParentageHelper, ExceptionToActionTable const &actions, std::shared_ptr< ActivityRegistry > areg, std::shared_ptr< ProcessConfiguration > processConfiguration, bool hasSubprocesses, PreallocationConfiguration const &config, ProcessContext const processContext)

bool	shouldWeCloseOutput () const

bool	terminate () const
	Return whether each output module has reached its maximum count. More...

int	totalEvents () const

int	totalEventsFailed () const

int	totalEventsPassed () const

void	triggerPaths (std::vector< std::string > &oLabelsToFill) const

void	writeLumiAsync (WaitingTaskHolder iTask, LuminosityBlockPrincipal const &lbp, ProcessContext const , ActivityRegistry )

void	writeProcessBlockAsync (WaitingTaskHolder iTask, ProcessBlockPrincipal const &, ProcessContext const , ActivityRegistry )

void	writeRunAsync (WaitingTaskHolder iTask, RunPrincipal const &rp, ProcessContext const , ActivityRegistry , MergeableRunProductMetadata const *)

Private Member Functions
void	limitOutput (ParameterSet const &proc_pset, BranchIDLists const &branchIDLists, SubProcessParentageHelper const *subProcessParentageHelper)

std::shared_ptr < ModuleRegistry const >	moduleRegistry () const

std::shared_ptr< ModuleRegistry > &	moduleRegistry ()

std::shared_ptr < TriggerResultInserter const >	resultsInserter () const

std::shared_ptr < TriggerResultInserter > &	resultsInserter ()

Private Attributes
AllOutputModuleCommunicators	all_output_communicators_

std::vector< std::string > const *	endPathNames_

std::vector < edm::propagate_const < std::shared_ptr < EndPathStatusInserter > > >	endPathStatusInserters_

edm::propagate_const < std::unique_ptr < GlobalSchedule > >	globalSchedule_

edm::propagate_const < std::shared_ptr < ModuleRegistry > >	moduleRegistry_

std::vector< std::string > const *	pathNames_

std::vector < edm::propagate_const < std::shared_ptr < PathStatusInserter > > >	pathStatusInserters_

PreallocationConfiguration	preallocConfig_

edm::propagate_const < std::shared_ptr < TriggerResultInserter > >	resultsInserter_

std::vector < edm::propagate_const < std::shared_ptr < StreamSchedule > > >	streamSchedules_

edm::propagate_const < std::unique_ptr < SystemTimeKeeper > >	summaryTimeKeeper_

bool	wantSummary_

Detailed Description

Definition at line 122 of file Schedule.h.

Member Typedef Documentation

typedef std::vector<edm::propagate_const<std::shared_ptr<OutputModuleCommunicator> > > edm::Schedule::AllOutputModuleCommunicators

Definition at line 126 of file Schedule.h.

typedef std::vector<Worker*> edm::Schedule::AllWorkers

Definition at line 125 of file Schedule.h.

typedef std::vector<std::string> edm::Schedule::vstring

Definition at line 124 of file Schedule.h.

typedef std::vector<Worker*> edm::Schedule::Workers

Definition at line 128 of file Schedule.h.

Constructor & Destructor Documentation

edm::Schedule::Schedule	(	ParameterSet &	proc_pset,
		service::TriggerNamesService const &	tns,
		ProductRegistry &	pregistry,
		BranchIDListHelper &	branchIDListHelper,
		ProcessBlockHelperBase &	processBlockHelper,
		ThinnedAssociationsHelper &	thinnedAssociationsHelper,
		SubProcessParentageHelper const *	subProcessParentageHelper,
		ExceptionToActionTable const &	actions,
		std::shared_ptr< ActivityRegistry >	areg,
		std::shared_ptr< ProcessConfiguration >	processConfiguration,
		bool	hasSubprocesses,
		PreallocationConfiguration const &	config,
		ProcessContext const *	processContext
	)

Definition at line 671 of file Schedule.cc.

References edm::service::TriggerNamesService::getTrigPaths().

       :  //Only create a resultsInserter if there is a trigger path
         resultsInserter_{tns.getTrigPaths().empty()
                              ? std::shared_ptr<TriggerResultInserter>{}

Member Function Documentation

Schedule::AllWorkers const & edm::Schedule::allWorkers ( ) const

returns the collection of pointers to workers

Definition at line 1451 of file Schedule.cc.

References globalSchedule_.

Referenced by changeModule(), closeOutputFiles(), convertCurrentProcessAlias(), edm::PathsAndConsumesOfModules::doConsumesInfo(), fillModuleAndConsumesInfo(), getAllModuleDescriptions(), respondToCloseInputFile(), and respondToOpenInputFile().

1451 { return globalSchedule_->allWorkers(); }

edm::Schedule::globalSchedule_

edm::propagate_const< std::unique_ptr< GlobalSchedule > > globalSchedule_

Definition: Schedule.h:306

void edm::Schedule::availablePaths ( std::vector< std::string > & oLabelsToFill ) const

adds to oLabelsToFill the labels for all paths in the process

Definition at line 1459 of file Schedule.cc.

References streamSchedules_.

Referenced by edm::ScheduleInfo::availablePaths().

                                                                          {
     streamSchedules_[0]->availablePaths(oLabelsToFill);
   }

void edm::Schedule::beginJob	(	ProductRegistry const &	iRegistry,
		eventsetup::ESRecordsToProxyIndices const &	iESIndices,
		ProcessBlockHelperBase const &	processBlockHelperBase
	)

Definition at line 1352 of file Schedule.cc.

References globalSchedule_.

                                                                                 {
     globalSchedule_->beginJob(iRegistry, iESIndices, processBlockHelperBase);
   }

void edm::Schedule::beginStream ( unsigned int iStreamID )

Definition at line 1358 of file Schedule.cc.

References cms::cuda::assert(), and streamSchedules_.

                                                    {
     assert(iStreamID < streamSchedules_.size());
     streamSchedules_[iStreamID]->beginStream();
   }

bool edm::Schedule::changeModule	(	std::string const &	iLabel,
		ParameterSet const &	iPSet,
		const ProductRegistry &	iRegistry,
		eventsetup::ESRecordsToProxyIndices const &	iIndices
	)

clone the type of module with label iLabel but configure with iPSet. Returns true if successful.

Definition at line 1376 of file Schedule.cc.

References allWorkers(), globalSchedule_, edm::InEvent, edm::InLumi, edm::InProcess, edm::InRun, moduleRegistry_, preallocConfig_, edm::ProductRegistry::productLookup(), edm::Worker::resolvePutIndicies(), streamSchedules_, and edm::Worker::updateLookup().

                                                                                  {
     Worker* found = nullptr;
     for (auto const& worker : allWorkers()) {
       if (worker->description()->moduleLabel() == iLabel) {
         found = worker;
         break;
       }
     }
     if (nullptr == found) {
       return false;
     }
 
     auto newMod = moduleRegistry_->replaceModule(iLabel, iPSet, preallocConfig_);
 
     globalSchedule_->replaceModule(newMod, iLabel);
 
     for (auto& s : streamSchedules_) {
       s->replaceModule(newMod, iLabel);
     }
 
     {
       //Need to updateLookup in order to make getByToken work
       auto const processBlockLookup = iRegistry.productLookup(InProcess);
       auto const runLookup = iRegistry.productLookup(InRun);
       auto const lumiLookup = iRegistry.productLookup(InLumi);
       auto const eventLookup = iRegistry.productLookup(InEvent);
       found->updateLookup(InProcess, *runLookup);
       found->updateLookup(InRun, *runLookup);
       found->updateLookup(InLumi, *lumiLookup);
       found->updateLookup(InEvent, *eventLookup);
       found->updateLookup(iIndices);
 
       auto const& processName = newMod->moduleDescription().processName();
       auto const& processBlockModuleToIndicies = processBlockLookup->indiciesForModulesInProcess(processName);
       auto const& runModuleToIndicies = runLookup->indiciesForModulesInProcess(processName);
       auto const& lumiModuleToIndicies = lumiLookup->indiciesForModulesInProcess(processName);
       auto const& eventModuleToIndicies = eventLookup->indiciesForModulesInProcess(processName);
       found->resolvePutIndicies(InProcess, processBlockModuleToIndicies);
       found->resolvePutIndicies(InRun, runModuleToIndicies);
       found->resolvePutIndicies(InLumi, lumiModuleToIndicies);
       found->resolvePutIndicies(InEvent, eventModuleToIndicies);
     }
 
     return true;
   }

void edm::Schedule::clearCounters ( )

Clear all the counters in the trigger report.

Definition at line 1575 of file Schedule.cc.

References streamSchedules_.

                                {
     for (auto& s : streamSchedules_) {
       s->clearCounters();
     }
   }

void edm::Schedule::closeOutputFiles ( )

Definition at line 1228 of file Schedule.cc.

References all_output_communicators_, allWorkers(), edm::OutputModuleCommunicator::closeFile(), and edm::for_all().

                                   {
     using std::placeholders::_1;
     for_all(all_output_communicators_, std::bind(&OutputModuleCommunicator::closeFile, _1));
     for (auto& worker : allWorkers()) {
       worker->respondToCloseOutputFile();
     }
   }

void edm::Schedule::convertCurrentProcessAlias ( std::string const & processName )

Convert "@currentProcess" in InputTag process names to the actual current process name.

Definition at line 1453 of file Schedule.cc.

References allWorkers().

                                                                         {
     for (auto const& worker : allWorkers()) {
       worker->convertCurrentProcessAlias(processName);
     }
   }

void edm::Schedule::deleteModule	(	std::string const &	iLabel,
		ActivityRegistry *	areg
	)

Deletes module with label iLabel.

Definition at line 1425 of file Schedule.cc.

References globalSchedule_, moduleRegistry_, edm::ActivityRegistry::postModuleDestructionSignal_, edm::ActivityRegistry::preModuleDestructionSignal_, cms::cuda::stream, and streamSchedules_.

                                                                              {
     globalSchedule_->deleteModule(iLabel);
     for (auto& stream : streamSchedules_) {
       stream->deleteModule(iLabel);
     }
     moduleRegistry_->deleteModule(iLabel, areg->preModuleDestructionSignal_, areg->postModuleDestructionSignal_);
   }

void edm::Schedule::endJob ( ExceptionCollector & collector )

Definition at line 945 of file Schedule.cc.

References visDQMUpload::context, edm::EventTimingSummary::cpuTime, edm::TriggerTimingReport::endPathSummaries, edm::TriggerReport::endPathSummaries, edm::TriggerTimingReport::eventSummary, edm::TriggerReport::eventSummary, getTriggerReport(), getTriggerTimingReport(), globalSchedule_, edm::ExceptionCollector::hasThrown(), SiStripPI::max, mod(), edm::PreallocationConfiguration::numberOfThreads(), AlCaHLTBitMon_ParallelJobs::p, preallocConfig_, edm::EventTimingSummary::realTime, streamSchedules_, edm::EventTimingSummary::sumStreamRealTime, edm::EventTimingSummary::totalEvents, edm::EventSummary::totalEvents, totalEvents(), edm::EventSummary::totalEventsFailed, edm::EventSummary::totalEventsPassed, edm::TriggerTimingReport::trigPathSummaries, edm::TriggerReport::trigPathSummaries, wantSummary_, edm::TriggerTimingReport::workerSummaries, and edm::TriggerReport::workerSummaries.

                                                      {
     globalSchedule_->endJob(collector);
     if (collector.hasThrown()) {
       return;
     }
 
     if (wantSummary_ == false)
       return;
     {
       TriggerReport tr;
       getTriggerReport(tr);
 
       // The trigger report (pass/fail etc.):
 
       LogFwkVerbatim("FwkSummary") << "";
       if (streamSchedules_[0]->context().processContext()->isSubProcess()) {
         LogFwkVerbatim("FwkSummary") << "TrigReport Process: "
                                      << streamSchedules_[0]->context().processContext()->processName();
       }
       LogFwkVerbatim("FwkSummary") << "TrigReport "
                                    << "---------- Event  Summary ------------";
       if (!tr.trigPathSummaries.empty()) {
         LogFwkVerbatim("FwkSummary") << "TrigReport"
                                      << " Events total = " << tr.eventSummary.totalEvents
                                      << " passed = " << tr.eventSummary.totalEventsPassed
                                      << " failed = " << tr.eventSummary.totalEventsFailed << "";
       } else {
         LogFwkVerbatim("FwkSummary") << "TrigReport"
                                      << " Events total = " << tr.eventSummary.totalEvents
                                      << " passed = " << tr.eventSummary.totalEvents << " failed = 0";
       }
 
       LogFwkVerbatim("FwkSummary") << "";
       LogFwkVerbatim("FwkSummary") << "TrigReport "
                                    << "---------- Path   Summary ------------";
       LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(10) << "Trig Bit#"
                                    << " " << std::right << std::setw(10) << "Executed"
                                    << " " << std::right << std::setw(10) << "Passed"
                                    << " " << std::right << std::setw(10) << "Failed"
                                    << " " << std::right << std::setw(10) << "Error"
                                    << " "
                                    << "Name"
                                    << "";
       for (auto const& p : tr.trigPathSummaries) {
         LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(5) << 1 << std::right << std::setw(5)
                                      << p.bitPosition << " " << std::right << std::setw(10) << p.timesRun << " "
                                      << std::right << std::setw(10) << p.timesPassed << " " << std::right
                                      << std::setw(10) << p.timesFailed << " " << std::right << std::setw(10)
                                      << p.timesExcept << " " << p.name << "";
       }
 
       /*
       std::vector<int>::const_iterator epi = empty_trig_paths_.begin();
       std::vector<int>::const_iterator epe = empty_trig_paths_.end();
       std::vector<std::string>::const_iterator  epn = empty_trig_path_names_.begin();
       for (; epi != epe; ++epi, ++epn) {
 
         LogFwkVerbatim("FwkSummary") << "TrigReport "
         << std::right << std::setw(5) << 1
         << std::right << std::setw(5) << *epi << " "
         << std::right << std::setw(10) << totalEvents() << " "
         << std::right << std::setw(10) << totalEvents() << " "
         << std::right << std::setw(10) << 0 << " "
         << std::right << std::setw(10) << 0 << " "
         << *epn << "";
       }
        */
 
       LogFwkVerbatim("FwkSummary") << "";
       LogFwkVerbatim("FwkSummary") << "TrigReport "
                                    << "-------End-Path   Summary ------------";
       LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(10) << "Trig Bit#"
                                    << " " << std::right << std::setw(10) << "Executed"
                                    << " " << std::right << std::setw(10) << "Passed"
                                    << " " << std::right << std::setw(10) << "Failed"
                                    << " " << std::right << std::setw(10) << "Error"
                                    << " "
                                    << "Name"
                                    << "";
       for (auto const& p : tr.endPathSummaries) {
         LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(5) << 0 << std::right << std::setw(5)
                                      << p.bitPosition << " " << std::right << std::setw(10) << p.timesRun << " "
                                      << std::right << std::setw(10) << p.timesPassed << " " << std::right
                                      << std::setw(10) << p.timesFailed << " " << std::right << std::setw(10)
                                      << p.timesExcept << " " << p.name << "";
       }
 
       for (auto const& p : tr.trigPathSummaries) {
         LogFwkVerbatim("FwkSummary") << "";
         LogFwkVerbatim("FwkSummary") << "TrigReport "
                                      << "---------- Modules in Path: " << p.name << " ------------";
         LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(10) << "Trig Bit#"
                                      << " " << std::right << std::setw(10) << "Visited"
                                      << " " << std::right << std::setw(10) << "Passed"
                                      << " " << std::right << std::setw(10) << "Failed"
                                      << " " << std::right << std::setw(10) << "Error"
                                      << " "
                                      << "Name"
                                      << "";
 
         unsigned int bitpos = 0;
         for (auto const& mod : p.moduleInPathSummaries) {
           LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(5) << 1 << std::right << std::setw(5)
                                        << bitpos << " " << std::right << std::setw(10) << mod.timesVisited << " "
                                        << std::right << std::setw(10) << mod.timesPassed << " " << std::right
                                        << std::setw(10) << mod.timesFailed << " " << std::right << std::setw(10)
                                        << mod.timesExcept << " " << mod.moduleLabel << "";
           ++bitpos;
         }
       }
 
       for (auto const& p : tr.endPathSummaries) {
         LogFwkVerbatim("FwkSummary") << "";
         LogFwkVerbatim("FwkSummary") << "TrigReport "
                                      << "------ Modules in End-Path: " << p.name << " ------------";
         LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(10) << "Trig Bit#"
                                      << " " << std::right << std::setw(10) << "Visited"
                                      << " " << std::right << std::setw(10) << "Passed"
                                      << " " << std::right << std::setw(10) << "Failed"
                                      << " " << std::right << std::setw(10) << "Error"
                                      << " "
                                      << "Name"
                                      << "";
 
         unsigned int bitpos = 0;
         for (auto const& mod : p.moduleInPathSummaries) {
           LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(5) << 0 << std::right << std::setw(5)
                                        << bitpos << " " << std::right << std::setw(10) << mod.timesVisited << " "
                                        << std::right << std::setw(10) << mod.timesPassed << " " << std::right
                                        << std::setw(10) << mod.timesFailed << " " << std::right << std::setw(10)
                                        << mod.timesExcept << " " << mod.moduleLabel << "";
           ++bitpos;
         }
       }
 
       LogFwkVerbatim("FwkSummary") << "";
       LogFwkVerbatim("FwkSummary") << "TrigReport "
                                    << "---------- Module Summary ------------";
       LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(10) << "Visited"
                                    << " " << std::right << std::setw(10) << "Executed"
                                    << " " << std::right << std::setw(10) << "Passed"
                                    << " " << std::right << std::setw(10) << "Failed"
                                    << " " << std::right << std::setw(10) << "Error"
                                    << " "
                                    << "Name"
                                    << "";
       for (auto const& worker : tr.workerSummaries) {
         LogFwkVerbatim("FwkSummary") << "TrigReport " << std::right << std::setw(10) << worker.timesVisited << " "
                                      << std::right << std::setw(10) << worker.timesRun << " " << std::right
                                      << std::setw(10) << worker.timesPassed << " " << std::right << std::setw(10)
                                      << worker.timesFailed << " " << std::right << std::setw(10) << worker.timesExcept
                                      << " " << worker.moduleLabel << "";
       }
       LogFwkVerbatim("FwkSummary") << "";
     }
     // The timing report (CPU and Real Time):
     TriggerTimingReport tr;
     getTriggerTimingReport(tr);
 
     const int totalEvents = std::max(1, tr.eventSummary.totalEvents);
 
     LogFwkVerbatim("FwkSummary") << "TimeReport "
                                  << "---------- Event  Summary ---[sec]----";
     LogFwkVerbatim("FwkSummary") << "TimeReport" << std::setprecision(6) << std::fixed
                                  << "       event loop CPU/event = " << tr.eventSummary.cpuTime / totalEvents;
     LogFwkVerbatim("FwkSummary") << "TimeReport" << std::setprecision(6) << std::fixed
                                  << "      event loop Real/event = " << tr.eventSummary.realTime / totalEvents;
     LogFwkVerbatim("FwkSummary") << "TimeReport" << std::setprecision(6) << std::fixed
                                  << "     sum Streams Real/event = " << tr.eventSummary.sumStreamRealTime / totalEvents;
     LogFwkVerbatim("FwkSummary") << "TimeReport" << std::setprecision(6) << std::fixed
                                  << " efficiency CPU/Real/thread = "
                                  << tr.eventSummary.cpuTime / tr.eventSummary.realTime /
                                         preallocConfig_.numberOfThreads();
 
     constexpr int kColumn1Size = 10;
     constexpr int kColumn2Size = 12;
     constexpr int kColumn3Size = 12;
     LogFwkVerbatim("FwkSummary") << "";
     LogFwkVerbatim("FwkSummary") << "TimeReport "
                                  << "---------- Path   Summary ---[Real sec]----";
     LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                  << " " << std::right << std::setw(kColumn2Size) << "per exec"
                                  << "  Name";
     for (auto const& p : tr.trigPathSummaries) {
       const int timesRun = std::max(1, p.timesRun);
       LogFwkVerbatim("FwkSummary") << "TimeReport " << std::setprecision(6) << std::fixed << std::right
                                    << std::setw(kColumn1Size) << p.realTime / totalEvents << " " << std::right
                                    << std::setw(kColumn2Size) << p.realTime / timesRun << "  " << p.name << "";
     }
     LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                  << " " << std::right << std::setw(kColumn2Size) << "per exec"
                                  << "  Name"
                                  << "";
 
     LogFwkVerbatim("FwkSummary") << "";
     LogFwkVerbatim("FwkSummary") << "TimeReport "
                                  << "-------End-Path   Summary ---[Real sec]----";
     LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                  << " " << std::right << std::setw(kColumn2Size) << "per exec"
                                  << "  Name"
                                  << "";
     for (auto const& p : tr.endPathSummaries) {
       const int timesRun = std::max(1, p.timesRun);
 
       LogFwkVerbatim("FwkSummary") << "TimeReport " << std::setprecision(6) << std::fixed << std::right
                                    << std::setw(kColumn1Size) << p.realTime / totalEvents << " " << std::right
                                    << std::setw(kColumn2Size) << p.realTime / timesRun << "  " << p.name << "";
     }
     LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                  << " " << std::right << std::setw(kColumn2Size) << "per exec"
                                  << "  Name"
                                  << "";
 
     for (auto const& p : tr.trigPathSummaries) {
       LogFwkVerbatim("FwkSummary") << "";
       LogFwkVerbatim("FwkSummary") << "TimeReport "
                                    << "---------- Modules in Path: " << p.name << " ---[Real sec]----";
       LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                    << " " << std::right << std::setw(kColumn2Size) << "per visit"
                                    << "  Name"
                                    << "";
       for (auto const& mod : p.moduleInPathSummaries) {
         LogFwkVerbatim("FwkSummary") << "TimeReport " << std::setprecision(6) << std::fixed << std::right
                                      << std::setw(kColumn1Size) << mod.realTime / totalEvents << " " << std::right
                                      << std::setw(kColumn2Size) << mod.realTime / std::max(1, mod.timesVisited) << "  "
                                      << mod.moduleLabel << "";
       }
     }
     if (not tr.trigPathSummaries.empty()) {
       LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                    << " " << std::right << std::setw(kColumn2Size) << "per visit"
                                    << "  Name"
                                    << "";
     }
     for (auto const& p : tr.endPathSummaries) {
       LogFwkVerbatim("FwkSummary") << "";
       LogFwkVerbatim("FwkSummary") << "TimeReport "
                                    << "------ Modules in End-Path: " << p.name << " ---[Real sec]----";
       LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                    << " " << std::right << std::setw(kColumn2Size) << "per visit"
                                    << "  Name"
                                    << "";
       for (auto const& mod : p.moduleInPathSummaries) {
         LogFwkVerbatim("FwkSummary") << "TimeReport " << std::setprecision(6) << std::fixed << std::right
                                      << std::setw(kColumn1Size) << mod.realTime / totalEvents << " " << std::right
                                      << std::setw(kColumn2Size) << mod.realTime / std::max(1, mod.timesVisited) << "  "
                                      << mod.moduleLabel << "";
       }
     }
     if (not tr.endPathSummaries.empty()) {
       LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                    << " " << std::right << std::setw(kColumn2Size) << "per visit"
                                    << "  Name"
                                    << "";
     }
     LogFwkVerbatim("FwkSummary") << "";
     LogFwkVerbatim("FwkSummary") << "TimeReport "
                                  << "---------- Module Summary ---[Real sec]----";
     LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                  << " " << std::right << std::setw(kColumn2Size) << "per exec"
                                  << " " << std::right << std::setw(kColumn3Size) << "per visit"
                                  << "  Name"
                                  << "";
     for (auto const& worker : tr.workerSummaries) {
       LogFwkVerbatim("FwkSummary") << "TimeReport " << std::setprecision(6) << std::fixed << std::right
                                    << std::setw(kColumn1Size) << worker.realTime / totalEvents << " " << std::right
                                    << std::setw(kColumn2Size) << worker.realTime / std::max(1, worker.timesRun) << " "
                                    << std::right << std::setw(kColumn3Size)
                                    << worker.realTime / std::max(1, worker.timesVisited) << "  " << worker.moduleLabel
                                    << "";
     }
     LogFwkVerbatim("FwkSummary") << "TimeReport " << std::right << std::setw(kColumn1Size) << "per event"
                                  << " " << std::right << std::setw(kColumn2Size) << "per exec"
                                  << " " << std::right << std::setw(kColumn3Size) << "per visit"
                                  << "  Name"
                                  << "";
 
     LogFwkVerbatim("FwkSummary") << "";
     LogFwkVerbatim("FwkSummary") << "T---Report end!"
                                  << "";
     LogFwkVerbatim("FwkSummary") << "";
   }

void edm::Schedule::endPaths ( std::vector< std::string > & oLabelsToFill ) const

adds to oLabelsToFill the labels for all end paths in the process

Definition at line 1465 of file Schedule.cc.

References endPathNames_.

Referenced by edm::PathsAndConsumesOfModules::initialize().

1465 { oLabelsToFill = *endPathNames_; }

edm::Schedule::endPathNames_

std::vector< std::string > const * endPathNames_

Definition: Schedule.h:314

void edm::Schedule::endStream ( unsigned int iStreamID )

Definition at line 1363 of file Schedule.cc.

References cms::cuda::assert(), and streamSchedules_.

                                                  {
     assert(iStreamID < streamSchedules_.size());
     streamSchedules_[iStreamID]->endStream();
   }

void edm::Schedule::fillModuleAndConsumesInfo	(	std::vector< ModuleDescription const * > &	allModuleDescriptions,
		std::vector< std::pair< unsigned int, unsigned int >> &	moduleIDToIndex,
		std::array< std::vector< std::vector< ModuleDescription const * >>, NumBranchTypes > &	modulesWhoseProductsAreConsumedBy,
		std::vector< std::vector< ModuleProcessName >> &	modulesInPreviousProcessesWhoseProductsAreConsumedBy,
		ProductRegistry const &	preg
	)		const

Definition at line 1483 of file Schedule.cc.

References cms::Exception::addContext(), allWorkers(), mps_fire::i, edm::ModuleDescription::id(), edm::ModuleDescription::moduleLabel(), TrackingSourceConfig_Tier0_Cosmic_cff::modules, edm::NumBranchTypes, AlCaHLTBitMon_ParallelJobs::p, findQualityFiles::size, and edm::sort_all().

Referenced by edm::PathsAndConsumesOfModules::initialize().

                                          {
     allModuleDescriptions.clear();
     moduleIDToIndex.clear();
     for (auto iBranchType = 0U; iBranchType < NumBranchTypes; ++iBranchType) {
       modulesWhoseProductsAreConsumedBy[iBranchType].clear();
     }
     modulesInPreviousProcessesWhoseProductsAreConsumedBy.clear();
 
     allModuleDescriptions.reserve(allWorkers().size());
     moduleIDToIndex.reserve(allWorkers().size());
     for (auto iBranchType = 0U; iBranchType < NumBranchTypes; ++iBranchType) {
       modulesWhoseProductsAreConsumedBy[iBranchType].resize(allWorkers().size());
     }
     modulesInPreviousProcessesWhoseProductsAreConsumedBy.resize(allWorkers().size());
 
     std::map<std::string, ModuleDescription const*> labelToDesc;
     unsigned int i = 0;
     for (auto const& worker : allWorkers()) {
       ModuleDescription const* p = worker->description();
       allModuleDescriptions.push_back(p);
       moduleIDToIndex.push_back(std::pair<unsigned int, unsigned int>(p->id(), i));
       labelToDesc[p->moduleLabel()] = p;
       ++i;
     }
     sort_all(moduleIDToIndex);
 
     i = 0;
     for (auto const& worker : allWorkers()) {
       std::array<std::vector<ModuleDescription const*>*, NumBranchTypes> modules;
       for (auto iBranchType = 0U; iBranchType < NumBranchTypes; ++iBranchType) {
         modules[iBranchType] = &modulesWhoseProductsAreConsumedBy[iBranchType].at(i);
       }
 
       std::vector<ModuleProcessName>& modulesInPreviousProcesses =
           modulesInPreviousProcessesWhoseProductsAreConsumedBy.at(i);
       try {
         worker->modulesWhoseProductsAreConsumed(modules, modulesInPreviousProcesses, preg, labelToDesc);
       } catch (cms::Exception& ex) {
         ex.addContext("Calling Worker::modulesWhoseProductsAreConsumed() for module " +
                       worker->description()->moduleLabel());
         throw;
       }
       ++i;
     }
   }

std::vector< ModuleDescription const * > edm::Schedule::getAllModuleDescriptions ( ) const

Return a vector allowing const access to all the ModuleDescriptions for this Schedule. *** N.B. *** Ownership of the ModuleDescriptions is not *** passed to the caller. Do not call delete on these *** pointers!

Definition at line 1440 of file Schedule.cc.

References allWorkers(), AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, and findQualityFiles::size.

Referenced by edm::ScheduleInfo::availableModuleLabels(), and edm::ScheduleInfo::parametersForModule().

                                                                                {
     std::vector<ModuleDescription const*> result;
     result.reserve(allWorkers().size());
 
     for (auto const& worker : allWorkers()) {
       ModuleDescription const* p = worker->description();
       result.push_back(p);
     }
     return result;
   }

void edm::Schedule::getTriggerReport ( TriggerReport & rep ) const

Return the trigger report information on paths, modules-in-path, modules-in-endpath, and modules.

Definition at line 1534 of file Schedule.cc.

References edm::TriggerReport::eventSummary, edm::sort_all(), streamSchedules_, edm::EventSummary::totalEvents, edm::EventSummary::totalEventsFailed, edm::EventSummary::totalEventsPassed, and edm::TriggerReport::workerSummaries.

Referenced by endJob().

                                                           {
     rep.eventSummary.totalEvents = 0;
     rep.eventSummary.totalEventsPassed = 0;
     rep.eventSummary.totalEventsFailed = 0;
     for (auto& s : streamSchedules_) {
       s->getTriggerReport(rep);
     }
     sort_all(rep.workerSummaries);
   }

void edm::Schedule::getTriggerTimingReport ( TriggerTimingReport & rep ) const

Return the trigger timing report information on paths, modules-in-path, modules-in-endpath, and modules.

Definition at line 1544 of file Schedule.cc.

References edm::EventTimingSummary::cpuTime, edm::TriggerTimingReport::eventSummary, edm::EventTimingSummary::realTime, summaryTimeKeeper_, and edm::EventTimingSummary::totalEvents.

Referenced by endJob().

                                                                       {
     rep.eventSummary.totalEvents = 0;
     rep.eventSummary.cpuTime = 0.;
     rep.eventSummary.realTime = 0.;
     summaryTimeKeeper_->fillTriggerTimingReport(rep);
   }

void edm::Schedule::initializeEarlyDelete	(	std::vector< std::string > const &	branchesToDeleteEarly,
		edm::ProductRegistry const &	preg
	)

Definition at line 1433 of file Schedule.cc.

References moduleRegistry(), cms::cuda::stream, and streamSchedules_.

                                                                        {
     for (auto& stream : streamSchedules_) {
       stream->initializeEarlyDelete(*moduleRegistry(), branchesToDeleteEarly, preg);
     }
   }

void edm::Schedule::limitOutput	(	ParameterSet const &	proc_pset,
		BranchIDLists const &	branchIDLists,
		SubProcessParentageHelper const *	subProcessParentageHelper
	)

private

Definition at line 889 of file Schedule.cc.

References all_output_communicators_, c, edm::errors::Configuration, submitPVResolutionJobs::desc, edm::ParameterSet::empty(), Exception, edm::ParameterSet::getParameterNamesForType(), edm::ParameterSet::getParameterSetNames(), edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), edm::OutputModuleDescription::maxEvents_, convertSQLitetoXML_cfg::output, edm::search_all(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
     std::string const output("output");
 
     ParameterSet const& maxEventsPSet = proc_pset.getUntrackedParameterSet("maxEvents");
     int maxEventSpecs = 0;
     int maxEventsOut = -1;
     ParameterSet const* vMaxEventsOut = nullptr;
     std::vector<std::string> intNamesE = maxEventsPSet.getParameterNamesForType<int>(false);
     if (search_all(intNamesE, output)) {
       maxEventsOut = maxEventsPSet.getUntrackedParameter<int>(output);
       ++maxEventSpecs;
     }
     std::vector<std::string> psetNamesE;
     maxEventsPSet.getParameterSetNames(psetNamesE, false);
     if (search_all(psetNamesE, output)) {
       vMaxEventsOut = &maxEventsPSet.getUntrackedParameterSet(output);
       ++maxEventSpecs;
     }
 
     if (maxEventSpecs > 1) {
       throw Exception(errors::Configuration)
           << "\nAt most, one form of 'output' may appear in the 'maxEvents' parameter set";
     }
 
     for (auto& c : all_output_communicators_) {
       OutputModuleDescription desc(branchIDLists, maxEventsOut, subProcessParentageHelper);
       if (vMaxEventsOut != nullptr && !vMaxEventsOut->empty()) {
         std::string const& moduleLabel = c->description().moduleLabel();
         try {
           desc.maxEvents_ = vMaxEventsOut->getUntrackedParameter<int>(moduleLabel);
         } catch (Exception const&) {
           throw Exception(errors::Configuration)
               << "\nNo entry in 'maxEvents' for output module label '" << moduleLabel << "'.\n";
         }
       }
       c->configure(desc);
     }
   }

void edm::Schedule::moduleDescriptionsInEndPath	(	std::string const &	iEndPathLabel,
		std::vector< ModuleDescription const * > &	descriptions,
		unsigned int	hint
	)		const

adds the ModuleDescriptions into the vector for the modules scheduled in path iEndPathLabel hint is a performance optimization if you might know the position of the module in the path

Definition at line 1477 of file Schedule.cc.

References streamSchedules_.

Referenced by edm::PathsAndConsumesOfModules::initialize().

                                                                       {
     streamSchedules_[0]->moduleDescriptionsInEndPath(iEndPathLabel, descriptions, hint);
   }

void edm::Schedule::moduleDescriptionsInPath	(	std::string const &	iPathLabel,
		std::vector< ModuleDescription const * > &	descriptions,
		unsigned int	hint
	)		const

adds the ModuleDescriptions into the vector for the modules scheduled in path iPathLabel hint is a performance optimization if you might know the position of the module in the path

Definition at line 1471 of file Schedule.cc.

References streamSchedules_.

Referenced by edm::PathsAndConsumesOfModules::initialize().

                                                                    {
     streamSchedules_[0]->moduleDescriptionsInPath(iPathLabel, descriptions, hint);
   }

std::shared_ptr<ModuleRegistry const> edm::Schedule::moduleRegistry ( ) const

inlineprivate

Definition at line 297 of file Schedule.h.

References edm::get_underlying_safe(), and moduleRegistry_.

Referenced by initializeEarlyDelete().

297 { return get_underlying_safe(moduleRegistry_); }

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

edm::Schedule::moduleRegistry_

edm::propagate_const< std::shared_ptr< ModuleRegistry > > moduleRegistry_

Definition: Schedule.h:303

std::shared_ptr<ModuleRegistry>& edm::Schedule::moduleRegistry ( )

inlineprivate

Definition at line 298 of file Schedule.h.

References edm::get_underlying_safe(), and moduleRegistry_.

298 { return get_underlying_safe(moduleRegistry_); }

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

edm::Schedule::moduleRegistry_

edm::propagate_const< std::shared_ptr< ModuleRegistry > > moduleRegistry_

Definition: Schedule.h:303

void edm::Schedule::modulesInPath	(	std::string const &	iPathLabel,
		std::vector< std::string > &	oLabelsToFill
	)		const

adds to oLabelsToFill in execution order the labels of all modules in path iPathLabel

Definition at line 1467 of file Schedule.cc.

References streamSchedules_.

Referenced by edm::ScheduleInfo::modulesInPath().

                                                                                                      {
     streamSchedules_[0]->modulesInPath(iPathLabel, oLabelsToFill);
   }

void edm::Schedule::openOutputFiles ( FileBlock & fb )

Definition at line 1236 of file Schedule.cc.

References all_output_communicators_, edm::for_all(), and edm::OutputModuleCommunicator::openFile().

                                               {
     using std::placeholders::_1;
     for_all(all_output_communicators_, std::bind(&OutputModuleCommunicator::openFile, _1, std::cref(fb)));
   }

void edm::Schedule::processOneEventAsync	(	WaitingTaskHolder	iTask,
		unsigned int	iStreamID,
		EventTransitionInfo &	info,
		ServiceToken const &	token
	)

Definition at line 1368 of file Schedule.cc.

References cms::cuda::assert(), eostools::move(), pathStatusInserters_, and streamSchedules_.

                                                                  {
     assert(iStreamID < streamSchedules_.size());
     streamSchedules_[iStreamID]->processOneEventAsync(std::move(iTask), info, token, pathStatusInserters_);
   }

template<typename T >

void edm::Schedule::processOneGlobalAsync	(	WaitingTaskHolder	iTask,
		typename T::TransitionInfoType &	transitionInfo,
		ServiceToken const &	token,
		bool	cleaningUpAfterException = `false`
	)

Definition at line 330 of file Schedule.h.

References globalSchedule_, and unpackBuffers-CaloStage2::token.

Referenced by edm::beginGlobalTransitionAsync(), and edm::endGlobalTransitionAsync().

                                                                       {
     globalSchedule_->processOneGlobalAsync<T>(iTaskHolder, transitionInfo, token, cleaningUpAfterException);
   }

template<typename T >

void edm::Schedule::processOneStreamAsync	(	WaitingTaskHolder	iTask,
		unsigned int	iStreamID,
		typename T::TransitionInfoType &	transitionInfo,
		ServiceToken const &	token,
		bool	cleaningUpAfterException = `false`
	)

Definition at line 319 of file Schedule.h.

References cms::cuda::assert(), eostools::move(), streamSchedules_, and unpackBuffers-CaloStage2::token.

Referenced by edm::beginStreamTransitionAsync(), and edm::endStreamTransitionAsync().

                                                                       {
     assert(iStreamID < streamSchedules_.size());
     streamSchedules_[iStreamID]->processOneStreamAsync<T>(
         std::move(iTaskHolder), transitionInfo, token, cleaningUpAfterException);
   }

void edm::Schedule::respondToCloseInputFile ( FileBlock const & fb )

Definition at line 1347 of file Schedule.cc.

References allWorkers(), edm::for_all(), and edm::Worker::respondToCloseInputFile().

                                                             {
     using std::placeholders::_1;
     for_all(allWorkers(), std::bind(&Worker::respondToCloseInputFile, _1, std::cref(fb)));
   }

void edm::Schedule::respondToOpenInputFile ( FileBlock const & fb )

Definition at line 1342 of file Schedule.cc.

References allWorkers(), edm::for_all(), and edm::Worker::respondToOpenInputFile().

                                                            {
     using std::placeholders::_1;
     for_all(allWorkers(), std::bind(&Worker::respondToOpenInputFile, _1, std::cref(fb)));
   }

std::shared_ptr<TriggerResultInserter const> edm::Schedule::resultsInserter ( ) const

inlineprivate

Definition at line 293 of file Schedule.h.

References edm::get_underlying_safe(), and resultsInserter_.

                                                                        {
       return get_underlying_safe(resultsInserter_);
     }

std::shared_ptr<TriggerResultInserter>& edm::Schedule::resultsInserter ( )

inlineprivate

Definition at line 296 of file Schedule.h.

References edm::get_underlying_safe(), and resultsInserter_.

296 { return get_underlying_safe(resultsInserter_); }

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

edm::Schedule::resultsInserter_

edm::propagate_const< std::shared_ptr< TriggerResultInserter > > resultsInserter_

Definition: Schedule.h:300

bool edm::Schedule::shouldWeCloseOutput ( ) const

Definition at line 1333 of file Schedule.cc.

References all_output_communicators_, and edm::OutputModuleCommunicator::shouldWeCloseFile().

                                            {
     using std::placeholders::_1;
     // Return true iff at least one output module returns true.
     return (std::find_if(all_output_communicators_.begin(),
                          all_output_communicators_.end(),
                          std::bind(&OutputModuleCommunicator::shouldWeCloseFile, _1)) !=
             all_output_communicators_.end());
   }

bool edm::Schedule::terminate ( void ) const

Return whether each output module has reached its maximum count.

Definition at line 930 of file Schedule.cc.

References all_output_communicators_, and c.

                                  {
     if (all_output_communicators_.empty()) {
       return false;
     }
     for (auto& c : all_output_communicators_) {
       if (!c->limitReached()) {
         // Found an output module that has not reached output event count.
         return false;
       }
     }
     LogInfo("SuccessfulTermination") << "The job is terminating successfully because each output module\n"
                                      << "has reached its configured limit.\n";
     return true;
   }

int edm::Schedule::totalEvents ( ) const

Return the number of events this Schedule has tried to process (inclues both successes and failures, including failures due to exceptions during processing).

Definition at line 1551 of file Schedule.cc.

References streamSchedules_.

Referenced by endJob().

                                   {
     int returnValue = 0;
     for (auto& s : streamSchedules_) {
       returnValue += s->totalEvents();
     }
     return returnValue;
   }

int edm::Schedule::totalEventsFailed ( ) const

Return the number of events that have not passed any trigger. (N.B. totalEventsFailed() + totalEventsPassed() == totalEvents()

Definition at line 1567 of file Schedule.cc.

References streamSchedules_.

                                         {
     int returnValue = 0;
     for (auto& s : streamSchedules_) {
       returnValue += s->totalEventsFailed();
     }
     return returnValue;
   }

int edm::Schedule::totalEventsPassed ( ) const

Return the number of events which have been passed by one or more trigger paths.

Definition at line 1559 of file Schedule.cc.

References streamSchedules_.

                                         {
     int returnValue = 0;
     for (auto& s : streamSchedules_) {
       returnValue += s->totalEventsPassed();
     }
     return returnValue;
   }

void edm::Schedule::triggerPaths ( std::vector< std::string > & oLabelsToFill ) const

Adds to oLabelsToFill the labels for all trigger paths in the process. This is different from availablePaths because it includes the empty paths to match the entries in TriggerResults exactly.

Definition at line 1463 of file Schedule.cc.

References pathNames_.

Referenced by edm::PathsAndConsumesOfModules::initialize().

1463 { oLabelsToFill = *pathNames_; }

edm::Schedule::pathNames_

std::vector< std::string > const * pathNames_

Definition: Schedule.h:313

void edm::Schedule::writeLumiAsync	(	WaitingTaskHolder	iTask,
		LuminosityBlockPrincipal const &	lbp,
		ProcessContext const *	processContext,
		ActivityRegistry *	activityRegistry
	)

Definition at line 1304 of file Schedule.cc.

References all_output_communicators_, edm::LuminosityBlockPrincipal::beginTime(), c, CMS_SA_ALLOW, first, edm::LuminosityBlockPrincipal::id(), edm::LuminosityBlockPrincipal::index(), edm::RunPrincipal::index(), edm::ServiceRegistry::instance(), edm::GlobalContext::kWriteLuminosityBlock, edm::ActivityRegistry::postGlobalWriteLumiSignal_, edm::ActivityRegistry::preGlobalWriteLumiSignal_, edm::ServiceRegistry::presentToken(), edm::waiting_task::chain::runLast(), edm::LuminosityBlockPrincipal::runPrincipal(), edm::waiting_task::chain::then(), and unpackBuffers-CaloStage2::token.

                                                                     {
     auto token = ServiceRegistry::instance().presentToken();
     GlobalContext globalContext(GlobalContext::Transition::kWriteLuminosityBlock,
                                 lbp.id(),
                                 lbp.runPrincipal().index(),
                                 lbp.index(),
                                 lbp.beginTime(),
                                 processContext);
 
     using namespace edm::waiting_task;
     chain::first([&](auto nextTask) {
       ServiceRegistry::Operate op(token);
       CMS_SA_ALLOW try { activityRegistry->preGlobalWriteLumiSignal_(globalContext); } catch (...) {
       }
       for (auto& c : all_output_communicators_) {
         c->writeLumiAsync(nextTask, lbp, processContext, activityRegistry);
       }
     }) | chain::then(doCleanup([activityRegistry, globalContext, token]() {
       //services can depend on other services
       ServiceRegistry::Operate op(token);
 
       activityRegistry->postGlobalWriteLumiSignal_(globalContext);
     })) |
         chain::runLast(task);
   }

void edm::Schedule::writeProcessBlockAsync	(	WaitingTaskHolder	iTask,
		ProcessBlockPrincipal const &	pbp,
		ProcessContext const *	processContext,
		ActivityRegistry *	activityRegistry
	)

Definition at line 1274 of file Schedule.cc.

References all_output_communicators_, c, CMS_SA_ALLOW, first, edm::ServiceRegistry::instance(), edm::LuminosityBlockIndex::invalidLuminosityBlockIndex(), edm::RunIndex::invalidRunIndex(), edm::Timestamp::invalidTimestamp(), edm::GlobalContext::kWriteProcessBlock, eostools::move(), edm::ActivityRegistry::postWriteProcessBlockSignal_, edm::ServiceRegistry::presentToken(), edm::ActivityRegistry::preWriteProcessBlockSignal_, edm::waiting_task::chain::runLast(), edm::waiting_task::chain::then(), and unpackBuffers-CaloStage2::token.

                                                                             {
     auto token = ServiceRegistry::instance().presentToken();
     GlobalContext globalContext(GlobalContext::Transition::kWriteProcessBlock,
                                 LuminosityBlockID(),
                                 RunIndex::invalidRunIndex(),
                                 LuminosityBlockIndex::invalidLuminosityBlockIndex(),
                                 Timestamp::invalidTimestamp(),
                                 processContext);
 
     using namespace edm::waiting_task;
     chain::first([&](auto nextTask) {
       // Propagating the exception would be nontrivial, and signal actions are not supposed to throw exceptions
       ServiceRegistry::Operate op(token);
       CMS_SA_ALLOW try { activityRegistry->preWriteProcessBlockSignal_(globalContext); } catch (...) {
       }
       for (auto& c : all_output_communicators_) {
         c->writeProcessBlockAsync(nextTask, pbp, processContext, activityRegistry);
       }
     }) | chain::then(doCleanup([activityRegistry, globalContext, token]() {
       //services can depend on other services
       ServiceRegistry::Operate op(token);
 
       activityRegistry->postWriteProcessBlockSignal_(globalContext);
     })) |
         chain::runLast(std::move(task));
   }

void edm::Schedule::writeRunAsync	(	WaitingTaskHolder	iTask,
		RunPrincipal const &	rp,
		ProcessContext const *	processContext,
		ActivityRegistry *	activityRegistry,
		MergeableRunProductMetadata const *	mergeableRunProductMetadata
	)

Definition at line 1241 of file Schedule.cc.

References all_output_communicators_, c, CMS_SA_ALLOW, edm::RunPrincipal::endTime(), first, edm::RunPrincipal::index(), edm::ServiceRegistry::instance(), edm::LuminosityBlockIndex::invalidLuminosityBlockIndex(), edm::GlobalContext::kWriteRun, edm::ActivityRegistry::postGlobalWriteRunSignal_, edm::ActivityRegistry::preGlobalWriteRunSignal_, edm::ServiceRegistry::presentToken(), edm::RunPrincipal::run(), edm::waiting_task::chain::runLast(), edm::waiting_task::chain::then(), and unpackBuffers-CaloStage2::token.

                                                                                                {
     auto token = ServiceRegistry::instance().presentToken();
     GlobalContext globalContext(GlobalContext::Transition::kWriteRun,
                                 LuminosityBlockID(rp.run(), 0),
                                 rp.index(),
                                 LuminosityBlockIndex::invalidLuminosityBlockIndex(),
                                 rp.endTime(),
                                 processContext);
 
     using namespace edm::waiting_task;
     chain::first([&](auto nextTask) {
       //services can depend on other services
       ServiceRegistry::Operate op(token);
 
       // Propagating the exception would be nontrivial, and signal actions are not supposed to throw exceptions
       CMS_SA_ALLOW try { activityRegistry->preGlobalWriteRunSignal_(globalContext); } catch (...) {
       }
       for (auto& c : all_output_communicators_) {
         c->writeRunAsync(nextTask, rp, processContext, activityRegistry, mergeableRunProductMetadata);
       }
     }) | chain::then(doCleanup([activityRegistry, globalContext, token]() {
       //services can depend on other services
       ServiceRegistry::Operate op(token);
 
       activityRegistry->postGlobalWriteRunSignal_(globalContext);
     })) |
         chain::runLast(task);
   }