edm::Schedule Class Reference

#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 &)
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	enableEndPaths (bool active)
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...
bool	endPathsEnabled () const
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	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, 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 > &	moduleRegistry ()
std::shared_ptr< ModuleRegistry const >	moduleRegistry () const
std::shared_ptr< TriggerResultInserter > &	resultsInserter ()
std::shared_ptr< TriggerResultInserter const >	resultsInserter () const

Private Attributes
AllOutputModuleCommunicators	all_output_communicators_
std::vector< std::string > const *	endPathNames_
volatile bool	endpathsAreActive_
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 121 of file Schedule.h.

Member Typedef Documentation

AllOutputModuleCommunicators

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

Definition at line 125 of file Schedule.h.

AllWorkers

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

Definition at line 124 of file Schedule.h.

vstring

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

Definition at line 123 of file Schedule.h.

Workers

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

Definition at line 127 of file Schedule.h.

Constructor & Destructor Documentation

Schedule()

edm::Schedule::Schedule	(	ParameterSet &	proc_pset,
		service::TriggerNamesService const &	tns,
		ProductRegistry &	pregistry,
		BranchIDListHelper &	branchIDListHelper,
		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 657 of file Schedule.cc.

      :  //Only create a resultsInserter if there is a trigger path
        resultsInserter_{tns.getTrigPaths().empty()
                             ? std::shared_ptr<TriggerResultInserter>{}
                             : makeInserter(proc_pset, prealloc, preg, actions, areg, processConfiguration)},
        moduleRegistry_(new ModuleRegistry()),
        all_output_communicators_(),
        preallocConfig_(prealloc),
        pathNames_(&tns.getTrigPaths()),
        endPathNames_(&tns.getEndPaths()),
        wantSummary_(tns.wantSummary()),
        endpathsAreActive_(true) {
    makePathStatusInserters(pathStatusInserters_,
                            *pathNames_,
                            prealloc,
                            preg,
                            areg,
                            processConfiguration,
                            std::string("PathStatusInserter"));
 
    makePathStatusInserters(endPathStatusInserters_,
                            *endPathNames_,
                            prealloc,
                            preg,
                            areg,
                            processConfiguration,
                            std::string("EndPathStatusInserter"));
 
    assert(0 < prealloc.numberOfStreams());
    streamSchedules_.reserve(prealloc.numberOfStreams());
    for (unsigned int i = 0; i < prealloc.numberOfStreams(); ++i) {
      streamSchedules_.emplace_back(make_shared_noexcept_false<StreamSchedule>(resultsInserter(),
                                                                               pathStatusInserters_,
                                                                               endPathStatusInserters_,
                                                                               moduleRegistry(),
                                                                               proc_pset,
                                                                               tns,
                                                                               prealloc,
                                                                               preg,
                                                                               branchIDListHelper,
                                                                               actions,
                                                                               areg,
                                                                               processConfiguration,
                                                                               !hasSubprocesses,
                                                                               StreamID{i},
                                                                               processContext));
    }
 
    //TriggerResults are injected automatically by StreamSchedules and are
    // unknown to the ModuleRegistry
    const std::string kTriggerResults("TriggerResults");
    std::vector<std::string> modulesToUse;
    modulesToUse.reserve(streamSchedules_[0]->allWorkers().size());
    for (auto const& worker : streamSchedules_[0]->allWorkers()) {
      if (worker->description()->moduleLabel() != kTriggerResults) {
        modulesToUse.push_back(worker->description()->moduleLabel());
      }
    }
    //The unscheduled modules are at the end of the list, but we want them at the front
    unsigned int const nUnscheduledModules = streamSchedules_[0]->numberOfUnscheduledModules();
    if (nUnscheduledModules > 0) {
      std::vector<std::string> temp;
      temp.reserve(modulesToUse.size());
      auto itBeginUnscheduled = modulesToUse.begin() + modulesToUse.size() - nUnscheduledModules;
      std::copy(itBeginUnscheduled, modulesToUse.end(), std::back_inserter(temp));
      std::copy(modulesToUse.begin(), itBeginUnscheduled, std::back_inserter(temp));
      temp.swap(modulesToUse);
    }
 
    // propagate_const<T> has no reset() function
    globalSchedule_ = std::make_unique<GlobalSchedule>(resultsInserter(),
                                                       pathStatusInserters_,
                                                       endPathStatusInserters_,
                                                       moduleRegistry(),
                                                       modulesToUse,
                                                       proc_pset,
                                                       preg,
                                                       prealloc,
                                                       actions,
                                                       areg,
                                                       processConfiguration,
                                                       processContext);
 
    //TriggerResults is not in the top level ParameterSet so the call to
    // reduceParameterSet would fail to find it. Just remove it up front.
    std::set<std::string> usedModuleLabels;
    for (auto const& worker : allWorkers()) {
      if (worker->description()->moduleLabel() != kTriggerResults) {
        usedModuleLabels.insert(worker->description()->moduleLabel());
      }
    }
    std::vector<std::string> modulesInConfig(proc_pset.getParameter<std::vector<std::string>>("@all_modules"));
    std::map<std::string, std::vector<std::pair<std::string, int>>> outputModulePathPositions;
    reduceParameterSet(proc_pset, tns.getEndPaths(), modulesInConfig, usedModuleLabels, outputModulePathPositions);
    processEDAliases(proc_pset, processConfiguration->processName(), preg);
 
    // At this point all BranchDescriptions are created. Mark now the
    // ones of unscheduled workers to be on-demand.
    if (nUnscheduledModules > 0) {
      std::set<std::string> unscheduledModules(modulesToUse.begin(), modulesToUse.begin() + nUnscheduledModules);
      preg.setUnscheduledProducts(unscheduledModules);
    }
 
    processSwitchProducers(proc_pset, processConfiguration->processName(), preg);
    proc_pset.registerIt();
    processConfiguration->setParameterSetID(proc_pset.id());
    processConfiguration->setProcessConfigurationID();
 
    // This is used for a little sanity-check to make sure no code
    // modifications alter the number of workers at a later date.
    size_t all_workers_count = allWorkers().size();
 
    moduleRegistry_->forAllModuleHolders([this](maker::ModuleHolder* iHolder) {
      auto comm = iHolder->createOutputModuleCommunicator();
      if (comm) {
        all_output_communicators_.emplace_back(std::shared_ptr<OutputModuleCommunicator>{comm.release()});
      }
    });
    // Now that the output workers are filled in, set any output limits or information.
    limitOutput(proc_pset, branchIDListHelper.branchIDLists(), subProcessParentageHelper);
 
    // Sanity check: make sure nobody has added a worker after we've
    // already relied on the WorkerManager being full.
    assert(all_workers_count == allWorkers().size());
 
    branchIDListHelper.updateFromRegistry(preg);
 
    for (auto const& worker : streamSchedules_[0]->allWorkers()) {
      worker->registerThinnedAssociations(preg, thinnedAssociationsHelper);
    }
 
    // The output modules consume products in kept branches.
    // So we must set this up before freezing.
    for (auto& c : all_output_communicators_) {
      c->selectProducts(preg, thinnedAssociationsHelper);
    }
 
    for (auto& product : preg.productListUpdator()) {
      setIsMergeable(product.second);
    }
 
    {
      // We now get a collection of types that may be consumed.
      std::set<TypeID> productTypesConsumed;
      std::set<TypeID> elementTypesConsumed;
      // Loop over all modules
      for (auto const& worker : allWorkers()) {
        for (auto const& consumesInfo : worker->consumesInfo()) {
          if (consumesInfo.kindOfType() == PRODUCT_TYPE) {
            productTypesConsumed.emplace(consumesInfo.type());
          } else {
            elementTypesConsumed.emplace(consumesInfo.type());
          }
        }
      }
      // The SubProcess class is not a module, yet it may consume.
      if (hasSubprocesses) {
        productTypesConsumed.emplace(typeid(TriggerResults));
      }
      // The RandomNumberGeneratorService is not a module, yet it consumes.
      { RngEDConsumer rngConsumer = RngEDConsumer(productTypesConsumed); }
      preg.setFrozen(productTypesConsumed, elementTypesConsumed, processConfiguration->processName());
    }
 
    for (auto& c : all_output_communicators_) {
      c->setEventSelectionInfo(outputModulePathPositions, preg.anyProductProduced());
    }
 
    if (wantSummary_) {
      std::vector<const ModuleDescription*> modDesc;
      const auto& workers = allWorkers();
      modDesc.reserve(workers.size());
 
      std::transform(workers.begin(),
                     workers.end(),
                     std::back_inserter(modDesc),
                     [](const Worker* iWorker) -> const ModuleDescription* { return iWorker->description(); });
 
      // propagate_const<T> has no reset() function
      summaryTimeKeeper_ = std::make_unique<SystemTimeKeeper>(prealloc.numberOfStreams(), modDesc, tns, processContext);
      auto timeKeeperPtr = summaryTimeKeeper_.get();
 
      areg->watchPreModuleDestruction(timeKeeperPtr, &SystemTimeKeeper::removeModuleIfExists);
 
      areg->watchPreModuleEvent(timeKeeperPtr, &SystemTimeKeeper::startModuleEvent);
      areg->watchPostModuleEvent(timeKeeperPtr, &SystemTimeKeeper::stopModuleEvent);
      areg->watchPreModuleEventAcquire(timeKeeperPtr, &SystemTimeKeeper::restartModuleEvent);
      areg->watchPostModuleEventAcquire(timeKeeperPtr, &SystemTimeKeeper::stopModuleEvent);
      areg->watchPreModuleEventDelayedGet(timeKeeperPtr, &SystemTimeKeeper::pauseModuleEvent);
      areg->watchPostModuleEventDelayedGet(timeKeeperPtr, &SystemTimeKeeper::restartModuleEvent);
 
      areg->watchPreSourceEvent(timeKeeperPtr, &SystemTimeKeeper::startEvent);
      areg->watchPostEvent(timeKeeperPtr, &SystemTimeKeeper::stopEvent);
 
      areg->watchPrePathEvent(timeKeeperPtr, &SystemTimeKeeper::startPath);
      areg->watchPostPathEvent(timeKeeperPtr, &SystemTimeKeeper::stopPath);
 
      areg->watchPostBeginJob(timeKeeperPtr, &SystemTimeKeeper::startProcessingLoop);
      areg->watchPreEndJob(timeKeeperPtr, &SystemTimeKeeper::stopProcessingLoop);
      //areg->preModuleEventSignal_.connect([timeKeeperPtr](StreamContext const& iContext, ModuleCallingContext const& iMod) {
      //timeKeeperPtr->startModuleEvent(iContext,iMod);
      //});
    }
 
  }  // Schedule::Schedule

References actions, and edm::service::TriggerNamesService::getTrigPaths().

Member Function Documentation

allWorkers()

Schedule::AllWorkers const & edm::Schedule::allWorkers

(

)

const

returns the collection of pointers to workers

Definition at line 1445 of file Schedule.cc.

{ return globalSchedule_->allWorkers(); }

References globalSchedule_.

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

availablePaths()

void edm::Schedule::availablePaths

(

std::vector< std::string > &

oLabelsToFill

)

const

adds to oLabelsToFill the labels for all paths in the process

Definition at line 1453 of file Schedule.cc.

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

References streamSchedules_.

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

beginJob()

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

Definition at line 1355 of file Schedule.cc.

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

References globalSchedule_.

beginStream()

void edm::Schedule::beginStream

(

unsigned int

iStreamID

)

Definition at line 1359 of file Schedule.cc.

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

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

changeModule()

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 1377 of file Schedule.cc.

                                                                                 {
    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;
  }

References allWorkers(), newFWLiteAna::found, globalSchedule_, edm::InEvent, edm::InLumi, edm::InProcess, edm::InRun, moduleRegistry_, preallocConfig_, SimL1EmulatorRepack_CalouGT_cff::processName, edm::ProductRegistry::productLookup(), alignCSCRings::s, and streamSchedules_.

clearCounters()

void edm::Schedule::clearCounters

(

)

Clear all the counters in the trigger report.

Definition at line 1578 of file Schedule.cc.

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

References alignCSCRings::s, and streamSchedules_.

closeOutputFiles()

void edm::Schedule::closeOutputFiles

(

)

Definition at line 1213 of file Schedule.cc.

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

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

convertCurrentProcessAlias()

void edm::Schedule::convertCurrentProcessAlias

(

std::string const &

processName

)

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

Definition at line 1447 of file Schedule.cc.

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

References allWorkers(), and SimL1EmulatorRepack_CalouGT_cff::processName.

deleteModule()

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

Deletes module with label iLabel.

Definition at line 1426 of file Schedule.cc.

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

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

enableEndPaths()

void edm::Schedule::enableEndPaths

(

bool

active

)

Turn end_paths "off" if "active" is false; turn end_paths "on" if "active" is true.

Definition at line 1528 of file Schedule.cc.

                                           {
    endpathsAreActive_ = active;
    for (auto& s : streamSchedules_) {
      s->enableEndPaths(active);
    }
  }

References endpathsAreActive_, alignCSCRings::s, and streamSchedules_.

endJob()

void edm::Schedule::endJob

(

ExceptionCollector &

collector

)

Definition at line 930 of file Schedule.cc.

                                                     {
    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") << "";
  }

References edm::EventTimingSummary::cpuTime, edm::TriggerTimingReport::endPathSummaries, edm::TriggerReport::endPathSummaries, edm::TriggerTimingReport::eventSummary, edm::TriggerReport::eventSummary, alignBH_cfg::fixed, 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.

endPaths()

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 1459 of file Schedule.cc.

{ oLabelsToFill = *endPathNames_; }

References endPathNames_.

endPathsEnabled()

bool edm::Schedule::endPathsEnabled

(

)

const

Return true if end_paths are active, and false if they are inactive.

Definition at line 1535 of file Schedule.cc.

{ return endpathsAreActive_; }

References endpathsAreActive_.

endStream()

void edm::Schedule::endStream

(

unsigned int

iStreamID

)

Definition at line 1364 of file Schedule.cc.

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

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

fillModuleAndConsumesInfo()

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 1477 of file Schedule.cc.

                                         {
    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;
    }
  }

References cms::Exception::addContext(), allWorkers(), mps_fire::i, LogMessageMonitor_cff::modules, edm::NumBranchTypes, AlCaHLTBitMon_ParallelJobs::p, findQualityFiles::size, edm::sort_all(), and mitigatedMETSequence_cff::U.

getAllModuleDescriptions()

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 1434 of file Schedule.cc.

                                                                               {
    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;
  }

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

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

getTriggerReport()

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 1537 of file Schedule.cc.

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

References cuy::rep, alignCSCRings::s, edm::sort_all(), and streamSchedules_.

Referenced by endJob().

getTriggerTimingReport()

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 1547 of file Schedule.cc.

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

References cuy::rep, and summaryTimeKeeper_.

Referenced by endJob().

limitOutput()

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

private

Definition at line 874 of file Schedule.cc.

                                                                                         {
    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);
    }
  }

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(), HerwigMaxPtPartonFilter_cfi::moduleLabel, convertSQLitetoXML_cfg::output, edm::search_all(), and AlCaHLTBitMon_QueryRunRegistry::string.

moduleDescriptionsInEndPath()

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 1471 of file Schedule.cc.

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

References streamSchedules_.

moduleDescriptionsInPath()

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 1465 of file Schedule.cc.

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

References streamSchedules_.

moduleRegistry() [1/2]

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

inlineprivate

Definition at line 302 of file Schedule.h.

{ return get_underlying_safe(moduleRegistry_); }

References edm::get_underlying_safe(), and moduleRegistry_.

moduleRegistry() [2/2]

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

inlineprivate

Definition at line 301 of file Schedule.h.

{ return get_underlying_safe(moduleRegistry_); }

References edm::get_underlying_safe(), and moduleRegistry_.

modulesInPath()

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 1461 of file Schedule.cc.

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

References streamSchedules_.

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

openOutputFiles()

void edm::Schedule::openOutputFiles

(

FileBlock &

fb

)

Definition at line 1218 of file Schedule.cc.

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

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

processOneEventAsync()

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

Definition at line 1369 of file Schedule.cc.

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

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

processOneGlobalAsync()

template<typename T >

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

Definition at line 336 of file Schedule.h.

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

References globalSchedule_, and unpackBuffers-CaloStage2::token.

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

processOneStreamAsync()

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 325 of file Schedule.h.

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

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

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

respondToCloseInputFile()

void edm::Schedule::respondToCloseInputFile

(

FileBlock const &

fb

)

Definition at line 1350 of file Schedule.cc.

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

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

respondToOpenInputFile()

void edm::Schedule::respondToOpenInputFile

(

FileBlock const &

fb

)

Definition at line 1345 of file Schedule.cc.

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

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

resultsInserter() [1/2]

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

inlineprivate

Definition at line 300 of file Schedule.h.

{ return get_underlying_safe(resultsInserter_); }

References edm::get_underlying_safe(), and resultsInserter_.

resultsInserter() [2/2]

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

inlineprivate

Definition at line 297 of file Schedule.h.

                                                                       {
      return get_underlying_safe(resultsInserter_);
    }

References edm::get_underlying_safe(), and resultsInserter_.

shouldWeCloseOutput()

bool edm::Schedule::shouldWeCloseOutput

(

)

const

Definition at line 1336 of file Schedule.cc.

                                           {
    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());
  }

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

terminate()

bool edm::Schedule::terminate

(

void

)

const

Return whether each output module has reached its maximum count.

Definition at line 915 of file Schedule.cc.

                                 {
    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;
  }

References all_output_communicators_, and c.

totalEvents()

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 1554 of file Schedule.cc.

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

References alignCSCRings::s, and streamSchedules_.

Referenced by endJob().

totalEventsFailed()

int edm::Schedule::totalEventsFailed

(

)

const

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

Definition at line 1570 of file Schedule.cc.

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

References alignCSCRings::s, and streamSchedules_.

totalEventsPassed()

int edm::Schedule::totalEventsPassed

(

)

const

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

Definition at line 1562 of file Schedule.cc.

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

References alignCSCRings::s, and streamSchedules_.

triggerPaths()

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 1457 of file Schedule.cc.

{ oLabelsToFill = *pathNames_; }

References pathNames_.

writeLumiAsync()

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

Definition at line 1299 of file Schedule.cc.

                                                                    {
    auto token = ServiceRegistry::instance().presentToken();
    GlobalContext globalContext(GlobalContext::Transition::kWriteLuminosityBlock,
                                lbp.id(),
                                lbp.runPrincipal().index(),
                                lbp.index(),
                                lbp.beginTime(),
                                processContext);
 
    auto t =
        make_waiting_task([task, activityRegistry, globalContext, token](std::exception_ptr const* iExcept) mutable {
          // Propagating the exception would be nontrivial, and signal actions are not supposed to throw exceptions
          CMS_SA_ALLOW try {
            //services can depend on other services
            ServiceRegistry::Operate op(token);
 
            activityRegistry->postGlobalWriteLumiSignal_(globalContext);
          } catch (...) {
          }
          std::exception_ptr ptr;
          if (iExcept) {
            ptr = *iExcept;
          }
          task.doneWaiting(ptr);
        });
    // Propagating the exception would be nontrivial, and signal actions are not supposed to throw exceptions
    CMS_SA_ALLOW try { activityRegistry->preGlobalWriteLumiSignal_(globalContext); } catch (...) {
    }
    WaitingTaskHolder tHolder(*task.group(), t);
    for (auto& c : all_output_communicators_) {
      c->writeLumiAsync(tHolder, lbp, processContext, activityRegistry);
    }
  }

References all_output_communicators_, edm::LuminosityBlockPrincipal::beginTime(), c, CMS_SA_ALLOW, edm::LuminosityBlockPrincipal::id(), edm::LuminosityBlockPrincipal::index(), edm::RunPrincipal::index(), edm::ServiceRegistry::instance(), edm::GlobalContext::kWriteLuminosityBlock, edm::make_waiting_task(), edm::ActivityRegistry::postGlobalWriteLumiSignal_, edm::ActivityRegistry::preGlobalWriteLumiSignal_, edm::ServiceRegistry::presentToken(), edm::LuminosityBlockPrincipal::runPrincipal(), submitPVValidationJobs::t, TrackValidation_cff::task, and unpackBuffers-CaloStage2::token.

writeProcessBlockAsync()

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

Definition at line 1261 of file Schedule.cc.

                                                                            {
    auto token = ServiceRegistry::instance().presentToken();
    GlobalContext globalContext(GlobalContext::Transition::kWriteProcessBlock,
                                LuminosityBlockID(),
                                RunIndex::invalidRunIndex(),
                                LuminosityBlockIndex::invalidLuminosityBlockIndex(),
                                Timestamp::invalidTimestamp(),
                                processContext);
 
    auto t =
        make_waiting_task([task, activityRegistry, globalContext, token](std::exception_ptr const* iExcept) mutable {
          // Propagating the exception would be nontrivial, and signal actions are not supposed to throw exceptions
          CMS_SA_ALLOW try {
            //services can depend on other services
            ServiceRegistry::Operate op(token);
 
            activityRegistry->postWriteProcessBlockSignal_(globalContext);
          } catch (...) {
          }
          std::exception_ptr ptr;
          if (iExcept) {
            ptr = *iExcept;
          }
          task.doneWaiting(ptr);
        });
    // Propagating the exception would be nontrivial, and signal actions are not supposed to throw exceptions
    CMS_SA_ALLOW try { activityRegistry->preWriteProcessBlockSignal_(globalContext); } catch (...) {
    }
    WaitingTaskHolder tHolder(*task.group(), t);
 
    for (auto& c : all_output_communicators_) {
      c->writeProcessBlockAsync(tHolder, pbp, processContext, activityRegistry);
    }
  }

References all_output_communicators_, c, CMS_SA_ALLOW, edm::ServiceRegistry::instance(), edm::LuminosityBlockIndex::invalidLuminosityBlockIndex(), edm::RunIndex::invalidRunIndex(), edm::Timestamp::invalidTimestamp(), edm::GlobalContext::kWriteProcessBlock, edm::make_waiting_task(), edm::ActivityRegistry::postWriteProcessBlockSignal_, edm::ServiceRegistry::presentToken(), edm::ActivityRegistry::preWriteProcessBlockSignal_, submitPVValidationJobs::t, TrackValidation_cff::task, and unpackBuffers-CaloStage2::token.

writeRunAsync()

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

Definition at line 1223 of file Schedule.cc.

                                                                                               {
    auto token = ServiceRegistry::instance().presentToken();
    GlobalContext globalContext(GlobalContext::Transition::kWriteRun,
                                LuminosityBlockID(rp.run(), 0),
                                rp.index(),
                                LuminosityBlockIndex::invalidLuminosityBlockIndex(),
                                rp.endTime(),
                                processContext);
    auto t =
        make_waiting_task([task, activityRegistry, globalContext, token](std::exception_ptr const* iExcept) mutable {
          // Propagating the exception would be nontrivial, and signal actions are not supposed to throw exceptions
          CMS_SA_ALLOW try {
            //services can depend on other services
            ServiceRegistry::Operate op(token);
 
            activityRegistry->postGlobalWriteRunSignal_(globalContext);
          } catch (...) {
          }
          std::exception_ptr ptr;
          if (iExcept) {
            ptr = *iExcept;
          }
          task.doneWaiting(ptr);
        });
    // Propagating the exception would be nontrivial, and signal actions are not supposed to throw exceptions
    CMS_SA_ALLOW try { activityRegistry->preGlobalWriteRunSignal_(globalContext); } catch (...) {
    }
    WaitingTaskHolder tHolder(*task.group(), t);
 
    for (auto& c : all_output_communicators_) {
      c->writeRunAsync(tHolder, rp, processContext, activityRegistry, mergeableRunProductMetadata);
    }
  }

References all_output_communicators_, c, CMS_SA_ALLOW, edm::RunPrincipal::endTime(), edm::RunPrincipal::index(), edm::ServiceRegistry::instance(), edm::LuminosityBlockIndex::invalidLuminosityBlockIndex(), edm::GlobalContext::kWriteRun, edm::make_waiting_task(), edm::ActivityRegistry::postGlobalWriteRunSignal_, edm::ActivityRegistry::preGlobalWriteRunSignal_, edm::ServiceRegistry::presentToken(), edm::RunPrincipal::run(), submitPVValidationJobs::t, TrackValidation_cff::task, and unpackBuffers-CaloStage2::token.

Member Data Documentation

all_output_communicators_

AllOutputModuleCommunicators edm::Schedule::all_output_communicators_

private

Definition at line 312 of file Schedule.h.

Referenced by closeOutputFiles(), limitOutput(), openOutputFiles(), shouldWeCloseOutput(), terminate(), writeLumiAsync(), writeProcessBlockAsync(), and writeRunAsync().

endPathNames_

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

private

Definition at line 318 of file Schedule.h.

Referenced by endPaths().

endpathsAreActive_

volatile bool edm::Schedule::endpathsAreActive_

private

Definition at line 321 of file Schedule.h.

Referenced by enableEndPaths(), and endPathsEnabled().

endPathStatusInserters_

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

private

Definition at line 306 of file Schedule.h.

globalSchedule_

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

private

Definition at line 310 of file Schedule.h.

Referenced by allWorkers(), beginJob(), changeModule(), deleteModule(), endJob(), and processOneGlobalAsync().

moduleRegistry_

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

private

Definition at line 307 of file Schedule.h.

Referenced by changeModule(), deleteModule(), and moduleRegistry().

pathNames_

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

private

Definition at line 317 of file Schedule.h.

Referenced by triggerPaths().

pathStatusInserters_

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

private

Definition at line 305 of file Schedule.h.

Referenced by processOneEventAsync().

preallocConfig_

PreallocationConfiguration edm::Schedule::preallocConfig_

private

Definition at line 313 of file Schedule.h.

Referenced by changeModule(), and endJob().

resultsInserter_

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

private

Definition at line 304 of file Schedule.h.

Referenced by resultsInserter().

streamSchedules_

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

private

Definition at line 308 of file Schedule.h.

Referenced by availablePaths(), beginStream(), changeModule(), clearCounters(), deleteModule(), enableEndPaths(), endJob(), endStream(), getTriggerReport(), moduleDescriptionsInEndPath(), moduleDescriptionsInPath(), modulesInPath(), processOneEventAsync(), processOneStreamAsync(), totalEvents(), totalEventsFailed(), and totalEventsPassed().

summaryTimeKeeper_

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

private

Definition at line 315 of file Schedule.h.

Referenced by getTriggerTimingReport().

wantSummary_

bool edm::Schedule::wantSummary_

private

Definition at line 319 of file Schedule.h.

Referenced by endJob().