#include <Schedule.h>

Public Types
typedef std::vector < boost::shared_ptr < OutputModuleCommunicator > >	AllOutputModuleCommunicators

typedef std::vector< Worker * >	AllWorkers

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

typedef boost::shared_ptr< Worker >	WorkerPtr

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 &)

void	beginStream (unsigned int)

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

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

void	closeOutputFiles ()

void	enableEndPaths (bool active)

void	endJob (ExceptionCollector &collector)

bool	endPathsEnabled () const

void	endStream (unsigned int)

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

void	getTriggerReport (TriggerReport &rep) const

void	getTriggerTimingReport (TriggerTimingReport &rep) 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	openNewOutputFilesIfNeeded ()

void	openOutputFiles (FileBlock &fb)

void	postForkReacquireResources (unsigned int iChildIndex, unsigned int iNumberOfChildren)

void	preForkReleaseResources ()

template<typename T >
void	processOneEvent (unsigned int iStreamID, typename T::MyPrincipal &principal, EventSetup const &eventSetup, bool cleaningUpAfterException=false)

template<typename T >
void	processOneGlobal (typename T::MyPrincipal &principal, EventSetup const &eventSetup, bool cleaningUpAfterException=false)

template<typename T >
void	processOneStream (unsigned int iStreamID, typename T::MyPrincipal &principal, EventSetup const &eventSetup, bool cleaningUpAfterException=false)

void	respondToCloseInputFile (FileBlock const &fb)

void	respondToOpenInputFile (FileBlock const &fb)

	Schedule (ParameterSet &proc_pset, service::TriggerNamesService &tns, ProductRegistry &pregistry, BranchIDListHelper &branchIDListHelper, ExceptionToActionTable const &actions, boost::shared_ptr< ActivityRegistry > areg, boost::shared_ptr< ProcessConfiguration > processConfiguration, const ParameterSet subProcPSet, 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	writeLumi (LuminosityBlockPrincipal const &lbp, ProcessContext const *)

void	writeRun (RunPrincipal const &rp, ProcessContext const *)

Private Member Functions
void	checkForCorrectness () const
	Check that the schedule is actually runable. More...

void	limitOutput (ParameterSet const &proc_pset, BranchIDLists const &branchIDLists)

Private Attributes
AllOutputModuleCommunicators	all_output_communicators_

volatile bool	endpathsAreActive_

std::unique_ptr< GlobalSchedule >	globalSchedule_

boost::shared_ptr< ModuleRegistry >	moduleRegistry_

PreallocationConfiguration	preallocConfig_

std::shared_ptr < TriggerResultInserter >	resultsInserter_

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

bool	wantSummary_

Detailed Description

Definition at line 109 of file Schedule.h.

Member Typedef Documentation

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

Definition at line 114 of file Schedule.h.

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

Definition at line 113 of file Schedule.h.

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

Definition at line 111 of file Schedule.h.

typedef boost::shared_ptr<Worker> edm::Schedule::WorkerPtr

Definition at line 112 of file Schedule.h.

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

Definition at line 116 of file Schedule.h.

Constructor & Destructor Documentation

edm::Schedule::Schedule	(	ParameterSet &	proc_pset,
		service::TriggerNamesService &	tns,
		ProductRegistry &	pregistry,
		BranchIDListHelper &	branchIDListHelper,
		ExceptionToActionTable const &	actions,
		boost::shared_ptr< ActivityRegistry >	areg,
		boost::shared_ptr< ProcessConfiguration >	processConfiguration,
		const ParameterSet *	subProcPSet,
		PreallocationConfiguration const &	config,
		ProcessContext const *	processContext
	)

Definition at line 358 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)},

Member Function Documentation

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

returns the collection of pointers to workers

Definition at line 968 of file Schedule.cc.

References globalSchedule_.

Referenced by changeModule(), checkForCorrectness(), getAllModuleDescriptions(), postForkReacquireResources(), preForkReleaseResources(), respondToCloseInputFile(), and respondToOpenInputFile().

                              {
     return globalSchedule_->allWorkers();
   }

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

adds to oLabelsToFill the labels for all paths in the process

Definition at line 973 of file Schedule.cc.

References streamSchedules_.

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

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

void edm::Schedule::beginJob ( ProductRegistry const & iRegistry )

Definition at line 897 of file Schedule.cc.

References checkForCorrectness(), and globalSchedule_.

                                                           {
     checkForCorrectness();
     
     globalSchedule_->beginJob(iRegistry);
   }

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

Definition at line 903 of file Schedule.cc.

References streamSchedules_.

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

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

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

Definition at line 920 of file Schedule.cc.

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

Referenced by edm::ModuleChanger::changeModule().

                                                                 {
     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 runLookup = iRegistry.productLookup(InRun);
       auto const lumiLookup = iRegistry.productLookup(InLumi);
       auto const eventLookup = iRegistry.productLookup(InEvent);
       found->updateLookup(InRun,*runLookup);
       found->updateLookup(InLumi,*lumiLookup);
       found->updateLookup(InEvent,*eventLookup);
     }
 
     return true;
   }

void edm::Schedule::checkForCorrectness ( ) const

private

Check that the schedule is actually runable.

Definition at line 1239 of file Schedule.cc.

References allWorkers(), newFWLiteAna::found, g, bookConverter::max, mergeVDriftHistosByStation::name, cmsHarvester::path, streamSchedules_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by beginJob().

   {
     //Need to lookup names to ids quickly
     std::map<std::string,unsigned int> moduleNamesToIndex;
     for(auto worker: allWorkers()) {
       moduleNamesToIndex.insert( std::make_pair(worker->description().moduleLabel(),
                                          worker->description().id()));
     }
     
     //If a module to module dependency comes from a path, remember which path
     EdgeToPathMap edgeToPathMap;
 
     //determine the path dependencies
     std::vector<std::string> pathNames;
     {
       streamSchedules_[0]->availablePaths(pathNames);
       
       std::vector<std::string> moduleNames;
       std::vector<std::string> reducedModuleNames;
       unsigned int pathIndex=0;
       for(auto const& path: pathNames) {
         moduleNames.clear();
         reducedModuleNames.clear();
         std::set<std::string> alreadySeenNames;
         
         streamSchedules_[0]->modulesInPath(path,moduleNames);
         std::string lastModuleName;
         unsigned int lastModuleIndex;
         for(auto const& name: moduleNames) {
           auto found = alreadySeenNames.insert(name);
           if(found.second) {
             //first time for this path
             unsigned int moduleIndex = moduleNamesToIndex[name];
             if(not lastModuleName.empty() ) {
               edgeToPathMap[std::make_pair(moduleIndex,lastModuleIndex)].push_back(pathIndex);
             }
             lastModuleName = name;
             lastModuleIndex = moduleIndex;
           }
         }
         ++pathIndex;
       }
     }
     {
       std::vector<const char*> dependentModules;
       //determine the data dependencies
       for(auto const& worker: allWorkers()) {
         dependentModules.clear();
         //NOTE: what about aliases?
         worker->modulesDependentUpon(dependentModules);
         auto found = moduleNamesToIndex.find(worker->description().moduleLabel());
         if (found == moduleNamesToIndex.end()) {
           //The module was from a previous process
           continue;
         }
         unsigned int moduleIndex = found->second;
         for(auto name: dependentModules) {
           edgeToPathMap[std::make_pair(moduleIndex, moduleNamesToIndex[name])].push_back(std::numeric_limits<unsigned int>::max());
         }
       }
     }
     //Now use boost graph library to find cycles in the dependencies
     std::vector<SimpleEdge> outList;
     outList.reserve(edgeToPathMap.size());
     for(auto const& edgeInfo: edgeToPathMap) {
       outList.push_back(edgeInfo.first);
     }
     
     Graph g(outList.begin(),outList.end(), moduleNamesToIndex.size());
     
     cycle_detector detector(edgeToPathMap,pathNames,moduleNamesToIndex);
     boost::depth_first_search(g,boost::visitor(detector));
   }

void edm::Schedule::clearCounters ( )

Clear all the counters in the trigger report.

Definition at line 1045 of file Schedule.cc.

References streamSchedules_.

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

void edm::Schedule::closeOutputFiles ( )

Definition at line 862 of file Schedule.cc.

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

                                   {
     for_all(all_output_communicators_, boost::bind(&OutputModuleCommunicator::closeFile, _1));
   }

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

References endpathsAreActive_, and streamSchedules_.

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

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

Definition at line 514 of file Schedule.cc.

References edm::EventTimingSummary::cpuTime, edm::TriggerTimingReport::endPathSummaries, edm::TriggerReport::endPathSummaries, edm::TriggerTimingReport::eventSummary, edm::TriggerReport::eventSummary, getTriggerReport(), getTriggerTimingReport(), globalSchedule_, edm::ExceptionCollector::hasThrown(), bookConverter::max, mod(), AlCaHLTBitMon_ParallelJobs::p, edm::EventTimingSummary::realTime, 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.):
       
       LogVerbatim("FwkSummary") << "";
       LogVerbatim("FwkSummary") << "TrigReport " << "---------- Event  Summary ------------";
       if(!tr.trigPathSummaries.empty()) {
         LogVerbatim("FwkSummary") << "TrigReport"
         << " Events total = " << tr.eventSummary.totalEvents
         << " passed = " << tr.eventSummary.totalEventsPassed
         << " failed = " << tr.eventSummary.totalEventsFailed
         << "";
       } else {
         LogVerbatim("FwkSummary") << "TrigReport"
         << " Events total = " << tr.eventSummary.totalEvents
         << " passed = " << tr.eventSummary.totalEvents
         << " failed = 0";
       }
       
       LogVerbatim("FwkSummary") << "";
       LogVerbatim("FwkSummary") << "TrigReport " << "---------- Path   Summary ------------";
       LogVerbatim("FwkSummary") << "TrigReport "
       << std::right << std::setw(10) << "Trig Bit#" << " "
       << std::right << std::setw(10) << "Run" << " "
       << 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) {
         LogVerbatim("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) {
         
         LogVerbatim("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 << "";
       }
        */
       
       LogVerbatim("FwkSummary") << "";
       LogVerbatim("FwkSummary") << "TrigReport " << "-------End-Path   Summary ------------";
       LogVerbatim("FwkSummary") << "TrigReport "
       << std::right << std::setw(10) << "Trig Bit#" << " "
       << std::right << std::setw(10) << "Run" << " "
       << 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) {
         LogVerbatim("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) {
         LogVerbatim("FwkSummary") << "";
         LogVerbatim("FwkSummary") << "TrigReport " << "---------- Modules in Path: " << p.name << " ------------";
         LogVerbatim("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) {
           LogVerbatim("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) {
         LogVerbatim("FwkSummary") << "";
         LogVerbatim("FwkSummary") << "TrigReport " << "------ Modules in End-Path: " << p.name << " ------------";
         LogVerbatim("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) {
           LogVerbatim("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;
         }
       }
       
       LogVerbatim("FwkSummary") << "";
       LogVerbatim("FwkSummary") << "TrigReport " << "---------- Module Summary ------------";
       LogVerbatim("FwkSummary") << "TrigReport "
       << std::right << std::setw(10) << "Visited" << " "
       << std::right << std::setw(10) << "Run" << " "
       << 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) {
         LogVerbatim("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 << "";
       }
       LogVerbatim("FwkSummary") << "";
     }
     // The timing report (CPU and Real Time):
     TriggerTimingReport tr;
     getTriggerTimingReport(tr);
 
     const int totalEvents = std::max(1, tr.eventSummary.totalEvents);
 
     LogVerbatim("FwkSummary") << "TimeReport " << "---------- Event  Summary ---[sec]----";
     LogVerbatim("FwkSummary") << "TimeReport"
                               << std::setprecision(6) << std::fixed
                               << " CPU/event = " << tr.eventSummary.cpuTime/totalEvents
                               << " Real/event = " << tr.eventSummary.realTime/totalEvents
                               << "";
 
     LogVerbatim("FwkSummary") << "";
     LogVerbatim("FwkSummary") << "TimeReport " << "---------- Path   Summary ---[sec]----";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(22) << "per event "
                               << std::right << std::setw(22) << "per path-run "
                               << "";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << "Name" << "";
     for (auto const& p: tr.trigPathSummaries) {
       const int timesRun = std::max(1, p.timesRun);
       LogVerbatim("FwkSummary") << "TimeReport "
                                 << std::setprecision(6) << std::fixed
                                 << std::right << std::setw(10) << p.cpuTime/totalEvents << " "
                                 << std::right << std::setw(10) << p.realTime/totalEvents << " "
                                 << std::right << std::setw(10) << p.cpuTime/timesRun << " "
                                 << std::right << std::setw(10) << p.realTime/timesRun << " "
                                 << p.name << "";
     }
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << "Name" << "";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(22) << "per event "
                               << std::right << std::setw(22) << "per path-run "
                               << "";
 
     LogVerbatim("FwkSummary") << "";
     LogVerbatim("FwkSummary") << "TimeReport " << "-------End-Path   Summary ---[sec]----";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(22) << "per event "
                               << std::right << std::setw(22) << "per endpath-run "
                               << "";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << "Name" << "";
     for (auto const& p: tr.endPathSummaries) {
       const int timesRun = std::max(1, p.timesRun);
 
       LogVerbatim("FwkSummary") << "TimeReport "
                                 << std::setprecision(6) << std::fixed
                                 << std::right << std::setw(10) << p.cpuTime/totalEvents << " "
                                 << std::right << std::setw(10) << p.realTime/totalEvents << " "
                                 << std::right << std::setw(10) << p.cpuTime/timesRun << " "
                                 << std::right << std::setw(10) << p.realTime/timesRun << " "
                                 << p.name << "";
     }
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << "Name" << "";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(22) << "per event "
                               << std::right << std::setw(22) << "per endpath-run "
                               << "";
 
     for (auto const& p: tr.trigPathSummaries) {
       LogVerbatim("FwkSummary") << "";
       LogVerbatim("FwkSummary") << "TimeReport " << "---------- Modules in Path: " << p.name << " ---[sec]----";
       LogVerbatim("FwkSummary") << "TimeReport "
                                 << std::right << std::setw(22) << "per event "
                                 << std::right << std::setw(22) << "per module-visit "
                                 << "";
       LogVerbatim("FwkSummary") << "TimeReport "
                                 << std::right << std::setw(10) << "CPU" << " "
                                 << std::right << std::setw(10) << "Real" << " "
                                 << std::right << std::setw(10) << "CPU" << " "
                                 << std::right << std::setw(10) << "Real" << " "
                                 << "Name" << "";
       for (auto const& mod: p.moduleInPathSummaries) {
         LogVerbatim("FwkSummary") << "TimeReport "
                                   << std::setprecision(6) << std::fixed
                                   << std::right << std::setw(10) << mod.cpuTime/totalEvents << " "
                                   << std::right << std::setw(10) << mod.realTime/totalEvents << " "
                                   << std::right << std::setw(10) << mod.cpuTime/std::max(1, mod.timesVisited) << " "
                                   << std::right << std::setw(10) << mod.realTime/std::max(1, mod.timesVisited) << " "
                                   << mod.moduleLabel << "";
       }
     }
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << "Name" << "";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(22) << "per event "
                               << std::right << std::setw(22) << "per module-visit "
                               << "";
 
     for (auto const& p: tr.endPathSummaries) {
       LogVerbatim("FwkSummary") << "";
       LogVerbatim("FwkSummary") << "TimeReport " << "------ Modules in End-Path: " << p.name << " ---[sec]----";
       LogVerbatim("FwkSummary") << "TimeReport "
                                 << std::right << std::setw(22) << "per event "
                                 << std::right << std::setw(22) << "per module-visit "
                                 << "";
       LogVerbatim("FwkSummary") << "TimeReport "
                                 << std::right << std::setw(10) << "CPU" << " "
                                 << std::right << std::setw(10) << "Real" << " "
                                 << std::right << std::setw(10) << "CPU" << " "
                                 << std::right << std::setw(10) << "Real" << " "
                                 << "Name" << "";
       for (auto const& mod: p.moduleInPathSummaries) {
         LogVerbatim("FwkSummary") << "TimeReport "
                                   << std::setprecision(6) << std::fixed
                                   << std::right << std::setw(10) << mod.cpuTime/totalEvents << " "
                                   << std::right << std::setw(10) << mod.realTime/totalEvents << " "
                                   << std::right << std::setw(10) << mod.cpuTime/std::max(1, mod.timesVisited) << " "
                                   << std::right << std::setw(10) << mod.realTime/std::max(1, mod.timesVisited) << " "
                                   << mod.moduleLabel << "";
       }
     }
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << "Name" << "";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(22) << "per event "
                               << std::right << std::setw(22) << "per module-visit "
                               << "";
 
     LogVerbatim("FwkSummary") << "";
     LogVerbatim("FwkSummary") << "TimeReport " << "---------- Module Summary ---[sec]----";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(22) << "per event "
                               << std::right << std::setw(22) << "per module-run "
                               << std::right << std::setw(22) << "per module-visit "
                               << "";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << "Name" << "";
     for (auto const& worker : tr.workerSummaries) {
       LogVerbatim("FwkSummary") << "TimeReport "
                                 << std::setprecision(6) << std::fixed
                                 << std::right << std::setw(10) << worker.cpuTime/totalEvents << " "
                                 << std::right << std::setw(10) << worker.realTime/totalEvents << " "
                                 << std::right << std::setw(10) << worker.cpuTime/std::max(1, worker.timesRun) << " "
                                 << std::right << std::setw(10) << worker.realTime/std::max(1, worker.timesRun) << " "
                                 << std::right << std::setw(10) << worker.cpuTime/std::max(1, worker.timesVisited) << " "
                                 << std::right << std::setw(10) << worker.realTime/std::max(1, worker.timesVisited) << " "
                                 << worker.moduleLabel << "";
     }
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << std::right << std::setw(10) << "CPU" << " "
                               << std::right << std::setw(10) << "Real" << " "
                               << "Name" << "";
     LogVerbatim("FwkSummary") << "TimeReport "
                               << std::right << std::setw(22) << "per event "
                               << std::right << std::setw(22) << "per module-run "
                               << std::right << std::setw(22) << "per module-visit "
                               << "";
 
     LogVerbatim("FwkSummary") << "";
     LogVerbatim("FwkSummary") << "T---Report end!" << "";
     LogVerbatim("FwkSummary") << "";
   }

bool edm::Schedule::endPathsEnabled ( ) const

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

Definition at line 992 of file Schedule.cc.

References endpathsAreActive_.

                                   {
     return endpathsAreActive_;
   }

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

Definition at line 908 of file Schedule.cc.

References streamSchedules_.

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

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

References allWorkers(), AlCaHLTBitMon_ParallelJobs::p, query::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->descPtr();
       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 997 of file Schedule.cc.

References edm::TriggerReport::eventSummary, streamSchedules_, edm::EventSummary::totalEvents, edm::EventSummary::totalEventsFailed, and edm::EventSummary::totalEventsPassed.

Referenced by endJob().

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

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

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

Referenced by endJob().

                                                                  {
     rep.eventSummary.totalEvents = 0;
     rep.eventSummary.cpuTime = 0.;
     rep.eventSummary.realTime = 0.;
     for(auto& s: streamSchedules_) {
       s->getTriggerTimingReport(rep);
     }
   }

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

private

Definition at line 459 of file Schedule.cc.

References all_output_communicators_, trackerHits::c, edm::errors::Configuration, edm::ParameterSet::empty(), edm::hlt::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", ParameterSet());
     int maxEventSpecs = 0;
     int maxEventsOut = -1;
     ParameterSet const* vMaxEventsOut = 0;
     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);
       if (vMaxEventsOut != 0 && !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::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 978 of file Schedule.cc.

References streamSchedules_.

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

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

void edm::Schedule::openNewOutputFilesIfNeeded ( )

Definition at line 866 of file Schedule.cc.

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

                                             {
     for_all(all_output_communicators_, boost::bind(&OutputModuleCommunicator::openNewFileIfNeeded, _1));
   }

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

Definition at line 870 of file Schedule.cc.

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

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

void edm::Schedule::postForkReacquireResources	(	unsigned int	iChildIndex,
		unsigned int	iNumberOfChildren
	)

Definition at line 916 of file Schedule.cc.

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

                                                                                                     {
     for_all(allWorkers(), boost::bind(&Worker::postForkReacquireResources, _1, iChildIndex, iNumberOfChildren));
   }

void edm::Schedule::preForkReleaseResources ( )

Definition at line 913 of file Schedule.cc.

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

                                          {
     for_all(allWorkers(), boost::bind(&Worker::preForkReleaseResources, _1));
   }

template<typename T >

void edm::Schedule::processOneEvent	(	unsigned int	iStreamID,
		typename T::MyPrincipal &	principal,
		EventSetup const &	eventSetup,
		bool	cleaningUpAfterException = `false`
	)

Definition at line 260 of file Schedule.h.

References streamSchedules_.

                                                                 {
     assert(iStreamID<streamSchedules_.size());
     streamSchedules_[iStreamID]->processOneEvent<T>(ep,es,cleaningUpAfterException);
   }

template<typename T >

void edm::Schedule::processOneGlobal	(	typename T::MyPrincipal &	principal,
		EventSetup const &	eventSetup,
		bool	cleaningUpAfterException = `false`
	)

Definition at line 278 of file Schedule.h.

References globalSchedule_.

                                                                 {
     globalSchedule_->processOneGlobal<T>(ep,es,cleaningUpAfterException);
   }

template<typename T >

void edm::Schedule::processOneStream	(	unsigned int	iStreamID,
		typename T::MyPrincipal &	principal,
		EventSetup const &	eventSetup,
		bool	cleaningUpAfterException = `false`
	)

Definition at line 269 of file Schedule.h.

References streamSchedules_.

                                                                  {
     assert(iStreamID<streamSchedules_.size());
     streamSchedules_[iStreamID]->processOneStream<T>(ep,es,cleaningUpAfterException);
   }

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

Definition at line 893 of file Schedule.cc.

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

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

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

Definition at line 889 of file Schedule.cc.

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

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

bool edm::Schedule::shouldWeCloseOutput ( ) const

Definition at line 882 of file Schedule.cc.

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

                                            {
     // Return true iff at least one output module returns true.
     return (std::find_if (all_output_communicators_.begin(), all_output_communicators_.end(),
                      boost::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 498 of file Schedule.cc.

References all_output_communicators_, and trackerHits::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 1017 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 1035 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 1026 of file Schedule.cc.

References streamSchedules_.

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

void edm::Schedule::writeLumi	(	LuminosityBlockPrincipal const &	lbp,
		ProcessContext const *	processContext
	)

Definition at line 878 of file Schedule.cc.

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

                                                                                                     {
     for_all(all_output_communicators_, boost::bind(&OutputModuleCommunicator::writeLumi, _1, boost::cref(lbp), processContext));
   }

void edm::Schedule::writeRun	(	RunPrincipal const &	rp,
		ProcessContext const *	processContext
	)

Definition at line 874 of file Schedule.cc.

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

                                                                                       {
     for_all(all_output_communicators_, boost::bind(&OutputModuleCommunicator::writeRun, _1, boost::cref(rp), processContext));
   }

Member Data Documentation

AllOutputModuleCommunicators edm::Schedule::all_output_communicators_

private

Definition at line 249 of file Schedule.h.

Referenced by closeOutputFiles(), limitOutput(), openNewOutputFilesIfNeeded(), openOutputFiles(), shouldWeCloseOutput(), terminate(), writeLumi(), and writeRun().

volatile bool edm::Schedule::endpathsAreActive_

private

Definition at line 255 of file Schedule.h.

Referenced by enableEndPaths(), and endPathsEnabled().

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

private

Definition at line 247 of file Schedule.h.

Referenced by allWorkers(), beginJob(), changeModule(), endJob(), and processOneGlobal().

boost::shared_ptr<ModuleRegistry> edm::Schedule::moduleRegistry_

private

Definition at line 244 of file Schedule.h.

Referenced by changeModule().

PreallocationConfiguration edm::Schedule::preallocConfig_

private

Definition at line 250 of file Schedule.h.

Referenced by changeModule().

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

private

Definition at line 243 of file Schedule.h.

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

private

Definition at line 245 of file Schedule.h.

Referenced by availablePaths(), beginStream(), changeModule(), checkForCorrectness(), clearCounters(), enableEndPaths(), endStream(), getTriggerReport(), getTriggerTimingReport(), modulesInPath(), processOneEvent(), processOneStream(), totalEvents(), totalEventsFailed(), and totalEventsPassed().

bool edm::Schedule::wantSummary_

private

Definition at line 253 of file Schedule.h.

Referenced by endJob().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation