#include <StreamSchedule.h>

Classes
class	SendTerminationSignalIfException

Public Types
typedef std::vector< Worker * >	AllWorkers

typedef std::vector< Path >	NonTrigPaths

typedef std::vector< WorkerInPath >	PathWorkers

typedef std::vector< Path >	TrigPaths

typedef std::shared_ptr < HLTGlobalStatus const >	TrigResConstPtr

typedef std::shared_ptr < HLTGlobalStatus >	TrigResPtr

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

typedef std::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	beginStream ()

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

void	enableEndPaths (bool active)

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

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

void	getTriggerReport (TriggerReport &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...

unsigned int	numberOfUnscheduledModules () const

void	processOneEvent (EventPrincipal &principal, EventSetup const &eventSetup, bool cleaningUpAfterException=false)

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

void	replaceModule (maker::ModuleHolder *iMod, std::string const &iLabel)
	clone the type of module with label iLabel but configure with iPSet. More...

StreamID	streamID () const

	StreamSchedule (std::shared_ptr< TriggerResultInserter > inserter, std::shared_ptr< ModuleRegistry >, ParameterSet &proc_pset, service::TriggerNamesService &tns, PreallocationConfiguration const &prealloc, ProductRegistry &pregistry, BranchIDListHelper &branchIDListHelper, ExceptionToActionTable const &actions, std::shared_ptr< ActivityRegistry > areg, std::shared_ptr< ProcessConfiguration > processConfiguration, bool allowEarlyDelete, StreamID streamID, ProcessContext const *processContext)

	StreamSchedule (StreamSchedule const &)=delete

int	totalEvents () const

int	totalEventsFailed () const

int	totalEventsPassed () const

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

Private Member Functions
ExceptionToActionTable const &	actionTable () const
	returns the action table More...

void	addToAllWorkers (Worker *w)

void	fillEndPath (ParameterSet &proc_pset, ProductRegistry &preg, PreallocationConfiguration const *prealloc, std::shared_ptr< ProcessConfiguration const > processConfiguration, int bitpos, std::string const &name)

void	fillTrigPath (ParameterSet &proc_pset, ProductRegistry &preg, PreallocationConfiguration const prealloc, std::shared_ptr< ProcessConfiguration const > processConfiguration, int bitpos, std::string const &name, TrigResPtr, vstring labelsOnTriggerPaths)

void	fillWorkers (ParameterSet &proc_pset, ProductRegistry &preg, PreallocationConfiguration const prealloc, std::shared_ptr< ProcessConfiguration const > processConfiguration, std::string const &name, bool ignoreFilters, PathWorkers &out, vstring labelsOnPaths)

void	initializeEarlyDelete (ModuleRegistry &modReg, edm::ParameterSet const &opts, edm::ProductRegistry const &preg, bool allowEarlyDelete)

void	reportSkipped (EventPrincipal const &ep) const

void	resetAll ()

void	resetEarlyDelete ()

TrigResConstPtr	results () const

TrigResPtr &	results ()

template<typename T >
void	runEndPaths (typename T::MyPrincipal const &, EventSetup const &, typename T::Context const *)

template<typename T >
bool	runTriggerPaths (typename T::MyPrincipal const &, EventSetup const &, typename T::Context const *)

Private Attributes
std::shared_ptr< ActivityRegistry >	actReg_

std::vector< BranchToCount >	earlyDeleteBranchToCount_

std::vector< EarlyDeleteHelper >	earlyDeleteHelpers_

std::vector< unsigned int >	earlyDeleteHelperToBranchIndicies_

vstring	empty_trig_path_names_

std::vector< int >	empty_trig_paths_

vstring	end_path_name_list_

TrigPaths	end_paths_

volatile bool	endpathsAreActive_

unsigned int	number_of_unscheduled_modules_

edm::propagate_const< TrigResPtr >	results_

edm::propagate_const< WorkerPtr >	results_inserter_

std::atomic< bool >	skippingEvent_

StreamContext	streamContext_

StreamID	streamID_

int	total_events_

int	total_passed_

vstring	trig_name_list_

TrigPaths	trig_paths_

WorkerManager	workerManager_

Detailed Description

Definition at line 140 of file StreamSchedule.h.

Member Typedef Documentation

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

Definition at line 148 of file StreamSchedule.h.

typedef std::vector<Path> edm::StreamSchedule::NonTrigPaths

Definition at line 144 of file StreamSchedule.h.

typedef std::vector<WorkerInPath> edm::StreamSchedule::PathWorkers

Definition at line 152 of file StreamSchedule.h.

typedef std::vector<Path> edm::StreamSchedule::TrigPaths

Definition at line 143 of file StreamSchedule.h.

typedef std::shared_ptr<HLTGlobalStatus const> edm::StreamSchedule::TrigResConstPtr

Definition at line 146 of file StreamSchedule.h.

typedef std::shared_ptr<HLTGlobalStatus> edm::StreamSchedule::TrigResPtr

Definition at line 145 of file StreamSchedule.h.

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

Definition at line 142 of file StreamSchedule.h.

typedef std::shared_ptr<Worker> edm::StreamSchedule::WorkerPtr

Definition at line 147 of file StreamSchedule.h.

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

Definition at line 150 of file StreamSchedule.h.

Constructor & Destructor Documentation

edm::StreamSchedule::StreamSchedule	(	std::shared_ptr< TriggerResultInserter >	inserter,
		std::shared_ptr< ModuleRegistry >	modReg,
		ParameterSet &	proc_pset,
		service::TriggerNamesService &	tns,
		PreallocationConfiguration const &	prealloc,
		ProductRegistry &	pregistry,
		BranchIDListHelper &	branchIDListHelper,
		ExceptionToActionTable const &	actions,
		std::shared_ptr< ActivityRegistry >	areg,
		std::shared_ptr< ProcessConfiguration >	processConfiguration,
		bool	allowEarlyDelete,
		StreamID	streamID,
		ProcessContext const *	processContext
	)

Definition at line 132 of file StreamSchedule.cc.

References actReg_, addToAllWorkers(), edm::WorkerManager::addToUnscheduledWorkers(), allWorkers(), assert(), end_path_name_list_, end_paths_, fillEndPath(), fillTrigPath(), edm::propagate_const< T >::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), initializeEarlyDelete(), diffTwoXMLs::label, number_of_unscheduled_modules_, geometryDiff::opts, results(), results_inserter_, edm::WorkerManager::setOnDemandProducts(), trig_name_list_, trig_paths_, edm::StreamID::value(), and workerManager_.

                                                                        :
     workerManager_(modReg,areg, actions),
     actReg_(areg),
     trig_name_list_(tns.getTrigPaths()),
     end_path_name_list_(tns.getEndPaths()),
     results_(new HLTGlobalStatus(trig_name_list_.size())),
     results_inserter_(),
     trig_paths_(),
     end_paths_(),
     total_events_(),
     total_passed_(),
     number_of_unscheduled_modules_(0),
     streamID_(streamID),
     streamContext_(streamID_, processContext),
     endpathsAreActive_(true),
     skippingEvent_(false){
 
     ParameterSet const& opts = proc_pset.getUntrackedParameterSet("options", ParameterSet());
     bool hasPath = false;
 
     int trig_bitpos = 0;
     trig_paths_.reserve(trig_name_list_.size());
     vstring labelsOnTriggerPaths;
       for (auto const& trig_name : trig_name_list_) {
       fillTrigPath(proc_pset, preg, &prealloc, processConfiguration, trig_bitpos, trig_name, results(), &labelsOnTriggerPaths);
       ++trig_bitpos;
       hasPath = true;
     }
 
     if (hasPath) {
       // the results inserter stands alone
       inserter->setTrigResultForStream(streamID.value(), results());
 
       results_inserter_ = makeInserter(actions, actReg_, inserter);
       addToAllWorkers(results_inserter_.get());
     }
 
     // fill normal endpaths
     int bitpos = 0;
     end_paths_.reserve(end_path_name_list_.size());
       for (auto const& end_path_name : end_path_name_list_) {
       fillEndPath(proc_pset, preg, &prealloc, processConfiguration, bitpos, end_path_name);
       ++bitpos;
     }
 
     //See if all modules were used
     std::set<std::string> usedWorkerLabels;
     for (auto const& worker : allWorkers()) {
       usedWorkerLabels.insert(worker->description().moduleLabel());
     }
     std::vector<std::string> modulesInConfig(proc_pset.getParameter<std::vector<std::string> >("@all_modules"));
     std::set<std::string> modulesInConfigSet(modulesInConfig.begin(), modulesInConfig.end());
     std::vector<std::string> unusedLabels;
     set_difference(modulesInConfigSet.begin(), modulesInConfigSet.end(),
                    usedWorkerLabels.begin(), usedWorkerLabels.end(),
                    back_inserter(unusedLabels));
     //does the configuration say we should allow on demand?
     bool allowUnscheduled = opts.getUntrackedParameter<bool>("allowUnscheduled", false);
     std::set<std::string> unscheduledLabels;
     std::vector<std::string>  shouldBeUsedLabels;
     if (!unusedLabels.empty()) {
       //Need to
       // 1) create worker
       // 2) if it is a WorkerT<EDProducer>, add it to our list
       // 3) hand list to our delayed reader
       for (auto const& label : unusedLabels) {
         if (allowUnscheduled) {
           bool isTracked;
           ParameterSet* modulePSet(proc_pset.getPSetForUpdate(label, isTracked));
           assert(isTracked);
           assert(modulePSet != nullptr);
           workerManager_.addToUnscheduledWorkers(*modulePSet, preg, &prealloc, processConfiguration, label, unscheduledLabels, shouldBeUsedLabels);
         } else {
           //everthing is marked are unused so no 'on demand' allowed
           shouldBeUsedLabels.push_back(label);
         }
       }
       if (!shouldBeUsedLabels.empty()) {
         std::ostringstream unusedStream;
         unusedStream << "'" << shouldBeUsedLabels.front() << "'";
         for (std::vector<std::string>::iterator itLabel = shouldBeUsedLabels.begin() + 1,
               itLabelEnd = shouldBeUsedLabels.end();
             itLabel != itLabelEnd;
             ++itLabel) {
           unusedStream << ",'" << *itLabel << "'";
         }
         LogInfo("path")
           << "The following module labels are not assigned to any path:\n"
           << unusedStream.str()
           << "\n";
       }
     }
     if (!unscheduledLabels.empty()) {
       number_of_unscheduled_modules_=unscheduledLabels.size();
       workerManager_.setOnDemandProducts(preg, unscheduledLabels);
     }
 
 
     initializeEarlyDelete(*modReg, opts,preg,allowEarlyDelete);
     
   } // StreamSchedule::StreamSchedule

edm::StreamSchedule::StreamSchedule ( StreamSchedule const & )

delete

Member Function Documentation

ExceptionToActionTable const& edm::StreamSchedule::actionTable ( ) const

inlineprivate

returns the action table

Definition at line 285 of file StreamSchedule.h.

References edm::WorkerManager::actionTable(), and workerManager_.

Referenced by fillEndPath(), fillTrigPath(), and processOneEvent().

                                                       {
       return workerManager_.actionTable();
     }

void edm::StreamSchedule::addToAllWorkers ( Worker * w )

private

Definition at line 825 of file StreamSchedule.cc.

References edm::WorkerManager::addToAllWorkers(), and workerManager_.

Referenced by fillEndPath(), fillTrigPath(), and StreamSchedule().

                                            {
     workerManager_.addToAllWorkers(w);
   }

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

inline

returns the collection of pointers to workers

Definition at line 253 of file StreamSchedule.h.

References edm::WorkerManager::allWorkers(), and workerManager_.

Referenced by clearCounters(), getAllModuleDescriptions(), getTriggerReport(), initializeEarlyDelete(), replaceModule(), and StreamSchedule().

                                          {
       return workerManager_.allWorkers();
     }

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

adds to oLabelsToFill the labels for all paths in the process

Definition at line 644 of file StreamSchedule.cc.

References edm::Path::name(), create_public_lumi_plots::transform, and trig_paths_.

                                                                           {
     oLabelsToFill.reserve(trig_paths_.size());
     std::transform(trig_paths_.begin(),
                    trig_paths_.end(),
                    std::back_inserter(oLabelsToFill),
                    std::bind(&Path::name, std::placeholders::_1));
   }

void edm::StreamSchedule::beginStream ( )

Definition at line 509 of file StreamSchedule.cc.

References edm::WorkerManager::beginStream(), streamContext_, streamID_, and workerManager_.

                                    {
     workerManager_.beginStream(streamID_, streamContext_);
   }

void edm::StreamSchedule::clearCounters ( )

Clear all the counters in the trigger report.

Definition at line 810 of file StreamSchedule.cc.

References allWorkers(), edm::Path::clearCounters(), edm::Worker::clearCounters(), end_paths_, edm::for_all(), total_events_, total_passed_, and trig_paths_.

                                 {
     using std::placeholders::_1;
     total_events_ = total_passed_ = 0;
     for_all(trig_paths_, std::bind(&Path::clearCounters, _1));
     for_all(end_paths_, std::bind(&Path::clearCounters, _1));
     for_all(allWorkers(), std::bind(&Worker::clearCounters, _1));
   }

void edm::StreamSchedule::enableEndPaths ( bool active )

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

Definition at line 738 of file StreamSchedule.cc.

References endpathsAreActive_.

                                             {
     endpathsAreActive_ = active;
   }

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

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

Definition at line 658 of file StreamSchedule.cc.

References end_path_name_list_.

                                                                     {
     oLabelsToFill = end_path_name_list_;
   }

bool edm::StreamSchedule::endPathsEnabled ( ) const

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

Definition at line 743 of file StreamSchedule.cc.

References endpathsAreActive_.

                                         {
     return endpathsAreActive_;
   }

void edm::StreamSchedule::endStream ( )

Definition at line 513 of file StreamSchedule.cc.

References edm::WorkerManager::endStream(), streamContext_, streamID_, and workerManager_.

                                  {
     workerManager_.endStream(streamID_, streamContext_);
   }

void edm::StreamSchedule::fillEndPath	(	ParameterSet &	proc_pset,
		ProductRegistry &	preg,
		PreallocationConfiguration const *	prealloc,
		std::shared_ptr< ProcessConfiguration const >	processConfiguration,
		int	bitpos,
		std::string const &	name
	)

private

Definition at line 488 of file StreamSchedule.cc.

References actionTable(), actReg_, addToAllWorkers(), end_paths_, fillWorkers(), edm::for_all(), edm::PathContext::kEndPath, and streamContext_.

Referenced by StreamSchedule().

                                                                       {
     using std::placeholders::_1;
     PathWorkers tmpworkers;
     fillWorkers(proc_pset, preg, prealloc, processConfiguration, name, true, tmpworkers, 0);
     Workers holder;
 
     for (PathWorkers::iterator wi(tmpworkers.begin()), we(tmpworkers.end()); wi != we; ++wi) {
       holder.push_back(wi->getWorker());
     }
 
     if (!tmpworkers.empty()) {
       //EndPaths are not supposed to stop if SkipEvent type exception happens
       end_paths_.emplace_back(bitpos, name, tmpworkers, TrigResPtr(), actionTable(), actReg_, &streamContext_, nullptr, PathContext::PathType::kEndPath);
     }
     for_all(holder, std::bind(&StreamSchedule::addToAllWorkers, this, _1));
   }

void edm::StreamSchedule::fillTrigPath	(	ParameterSet &	proc_pset,
		ProductRegistry &	preg,
		PreallocationConfiguration const *	prealloc,
		std::shared_ptr< ProcessConfiguration const >	processConfiguration,
		int	bitpos,
		std::string const &	name,
		TrigResPtr	trptr,
		vstring *	labelsOnTriggerPaths
	)

private

Definition at line 462 of file StreamSchedule.cc.

References actionTable(), actReg_, addToAllWorkers(), empty_trig_path_names_, empty_trig_paths_, fillWorkers(), edm::for_all(), edm::PathContext::kPath, skippingEvent_, streamContext_, and trig_paths_.

Referenced by StreamSchedule().

                                                                    {
     using std::placeholders::_1;
     PathWorkers tmpworkers;
     Workers holder;
     fillWorkers(proc_pset, preg, prealloc, processConfiguration, name, false, tmpworkers, labelsOnTriggerPaths);
 
     for (PathWorkers::iterator wi(tmpworkers.begin()),
           we(tmpworkers.end()); wi != we; ++wi) {
       holder.push_back(wi->getWorker());
     }
 
     // an empty path will cause an extra bit that is not used
     if (!tmpworkers.empty()) {
       trig_paths_.emplace_back(bitpos, name, tmpworkers, trptr, actionTable(), actReg_, &streamContext_, &skippingEvent_, PathContext::PathType::kPath);
     } else {
       empty_trig_paths_.push_back(bitpos);
       empty_trig_path_names_.push_back(name);
     }
     for_all(holder, std::bind(&StreamSchedule::addToAllWorkers, this, _1));
   }

void edm::StreamSchedule::fillWorkers	(	ParameterSet &	proc_pset,
		ProductRegistry &	preg,
		PreallocationConfiguration const *	prealloc,
		std::shared_ptr< ProcessConfiguration const >	processConfiguration,
		std::string const &	name,
		bool	ignoreFilters,
		PathWorkers &	out,
		vstring *	labelsOnPaths
	)

private

Definition at line 403 of file StreamSchedule.cc.

References assert(), edm::errors::Configuration, edm::Worker::description(), end_path_name_list_, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ParameterSet::getUntrackedParameter(), edm::WorkerManager::getWorker(), edm::WorkerInPath::Ignore, edm::Worker::kFilter, edm::ModuleDescription::moduleName(), edm::Worker::moduleType(), mergeVDriftHistosByStation::name, edm::WorkerInPath::Normal, EgammaValidation_cff::pathName, edm::search_all(), AlCaHLTBitMon_QueryRunRegistry::string, edm::WorkerInPath::Veto, and workerManager_.

Referenced by fillEndPath(), and fillTrigPath().

                                                            {
     vstring modnames = proc_pset.getParameter<vstring>(pathName);
     PathWorkers tmpworkers;
 
     unsigned int placeInPath = 0;
     for (auto const& name : modnames) {
 
       if (labelsOnPaths) labelsOnPaths->push_back(name);
 
       WorkerInPath::FilterAction filterAction = WorkerInPath::Normal;
       if (name[0] == '!')       filterAction = WorkerInPath::Veto;
       else if (name[0] == '-')  filterAction = WorkerInPath::Ignore;
 
       std::string moduleLabel = name;
       if (filterAction != WorkerInPath::Normal) moduleLabel.erase(0, 1);
 
       bool isTracked;
       ParameterSet* modpset = proc_pset.getPSetForUpdate(moduleLabel, isTracked);
       if (modpset == 0) {
         std::string pathType("endpath");
         if (!search_all(end_path_name_list_, pathName)) {
           pathType = std::string("path");
         }
         throw Exception(errors::Configuration) <<
           "The unknown module label \"" << moduleLabel <<
           "\" appears in " << pathType << " \"" << pathName <<
           "\"\n please check spelling or remove that label from the path.";
       }
       assert(isTracked);
 
       Worker* worker = workerManager_.getWorker(*modpset, preg, prealloc, processConfiguration, moduleLabel);
       if (ignoreFilters && filterAction != WorkerInPath::Ignore && worker->moduleType()==Worker::kFilter) {
         // We have a filter on an end path, and the filter is not explicitly ignored.
         // See if the filter is allowed.
         std::vector<std::string> allowed_filters = proc_pset.getUntrackedParameter<vstring>("@filters_on_endpaths");
         if (!search_all(allowed_filters, worker->description().moduleName())) {
           // Filter is not allowed. Ignore the result, and issue a warning.
           filterAction = WorkerInPath::Ignore;
           LogWarning("FilterOnEndPath")
             << "The EDFilter '" << worker->description().moduleName() << "' with module label '" << moduleLabel << "' appears on EndPath '" << pathName << "'.\n"
             << "The return value of the filter will be ignored.\n"
             << "To suppress this warning, either remove the filter from the endpath,\n"
             << "or explicitly ignore it in the configuration by using cms.ignore().\n";
         }
       }
       tmpworkers.emplace_back(worker, filterAction, placeInPath);
       ++placeInPath;
     }
 
     out.swap(tmpworkers);
   }

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

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

Definition at line 535 of file StreamSchedule.cc.

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

                                                  {
     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::StreamSchedule::getTriggerReport ( TriggerReport & rep ) const

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

Definition at line 798 of file StreamSchedule.cc.

References allWorkers(), end_paths_, edm::TriggerReport::endPathSummaries, edm::TriggerReport::eventSummary, edm::fillPathSummary(), edm::fillWorkerSummary(), edm::sort_all(), edm::EventSummary::totalEvents, totalEvents(), edm::EventSummary::totalEventsFailed, totalEventsFailed(), edm::EventSummary::totalEventsPassed, totalEventsPassed(), trig_paths_, edm::TriggerReport::trigPathSummaries, and edm::TriggerReport::workerSummaries.

                                                            {
     rep.eventSummary.totalEvents += totalEvents();
     rep.eventSummary.totalEventsPassed += totalEventsPassed();
     rep.eventSummary.totalEventsFailed += totalEventsFailed();
 
     fill_summary(trig_paths_,  rep.trigPathSummaries, &fillPathSummary);
     fill_summary(end_paths_,   rep.endPathSummaries,  &fillPathSummary);
     fill_summary(allWorkers(), rep.workerSummaries,   &fillWorkerSummary);
     sort_all(rep.workerSummaries);
   }

void edm::StreamSchedule::initializeEarlyDelete	(	ModuleRegistry &	modReg,
		edm::ParameterSet const &	opts,
		edm::ProductRegistry const &	preg,
		bool	allowEarlyDelete
	)

private

Definition at line 247 of file StreamSchedule.cc.

References allWorkers(), edm::BranchDescription::branchName(), edm::maker::ModuleHolder::createOutputModuleCommunicator(), delta, earlyDeleteBranchToCount_, earlyDeleteHelpers_, earlyDeleteHelperToBranchIndicies_, end_paths_, edm::ModuleRegistry::forAllModuleHolders(), newFWLiteAna::found, edm::pset::Registry::getMapped(), cmsHarvester::index, edm::InEvent, edm::pset::Registry::instance(), cmsLHEtoEOSManager::l, gen::n, AlCaHLTBitMon_ParallelJobs::p, TrackValidation_cff::pset, resetEarlyDelete(), AlCaHLTBitMon_QueryRunRegistry::string, trig_paths_, and w.

Referenced by StreamSchedule().

                                                               {
     //for now, if have a subProcess, don't allow early delete
     // In the future we should use the SubProcess's 'keep list' to decide what can be kept
     if(not allowEarlyDelete)  return;
 
     //see if 'canDeleteEarly' was set and if so setup the list with those products actually
     // registered for this job
     std::multimap<std::string,Worker*> branchToReadingWorker;
     initializeBranchToReadingWorker(opts,preg,branchToReadingWorker);
     
     //If no delete early items have been specified we don't have to do anything
     if(branchToReadingWorker.size()==0) {
       return;
     }
     const std::vector<std::string> kEmpty;
     std::map<Worker*,unsigned int> reserveSizeForWorker;
     unsigned int upperLimitOnReadingWorker =0;
     unsigned int upperLimitOnIndicies = 0;
     unsigned int nUniqueBranchesToDelete=branchToReadingWorker.size();
     
     //talk with output modules first
     modReg.forAllModuleHolders([this, &branchToReadingWorker,&nUniqueBranchesToDelete](maker::ModuleHolder* iHolder){
       auto comm = iHolder->createOutputModuleCommunicator();
       if (comm) {
         if(branchToReadingWorker.size()>0) {
           //If an OutputModule needs a product, we can't delete it early
           // so we should remove it from our list
           SelectedProductsForBranchType const& kept = comm->keptProducts();
           for(auto const& item: kept[InEvent]) {
             BranchDescription const& desc = *item.first;
             auto found = branchToReadingWorker.equal_range(desc.branchName());
             if(found.first !=found.second) {
               --nUniqueBranchesToDelete;
               branchToReadingWorker.erase(found.first,found.second);
             }
           }
         }
       }
     });
     
     if(branchToReadingWorker.size()==0) {
       return;
     }
     
     for (auto w :allWorkers()) {
       //determine if this module could read a branch we want to delete early
       auto pset = pset::Registry::instance()->getMapped(w->description().parameterSetID());
       if(0!=pset) {
         auto branches = pset->getUntrackedParameter<std::vector<std::string>>("mightGet",kEmpty);
         if(not branches.empty()) {
           ++upperLimitOnReadingWorker;
         }
         for(auto const& branch:branches){
           auto found = branchToReadingWorker.equal_range(branch);
           if(found.first != found.second) {
             ++upperLimitOnIndicies;
             ++reserveSizeForWorker[w];
             if(nullptr == found.first->second) {
               found.first->second = w;
             } else {
               branchToReadingWorker.insert(make_pair(found.first->first,w));
             }
           }
         }
       }
     }
     {
       auto it = branchToReadingWorker.begin();
       std::vector<std::string> unusedBranches;
       while(it !=branchToReadingWorker.end()) {
         if(it->second == nullptr) {
           unusedBranches.push_back(it->first);
           //erasing the object invalidates the iterator so must advance it first
           auto temp = it;
           ++it;
           branchToReadingWorker.erase(temp);
         } else {
           ++it;
         }
       }
       if(not unusedBranches.empty()) {
         LogWarning l("UnusedProductsForCanDeleteEarly");
         l<<"The following products in the 'canDeleteEarly' list are not used in this job and will be ignored.\n"
         " If possible, remove the producer from the job or add the product to the producer's own 'mightGet' list.";
         for(auto const& n:unusedBranches){
           l<<"\n "<<n;
         }
       }
     }  
     if(0!=branchToReadingWorker.size()) {
       earlyDeleteHelpers_.reserve(upperLimitOnReadingWorker);
       earlyDeleteHelperToBranchIndicies_.resize(upperLimitOnIndicies,0);
       earlyDeleteBranchToCount_.reserve(nUniqueBranchesToDelete);
       std::map<const Worker*,EarlyDeleteHelper*> alreadySeenWorkers;
       std::string lastBranchName;
       size_t nextOpenIndex = 0;
       unsigned int* beginAddress = &(earlyDeleteHelperToBranchIndicies_.front());
       for(auto& branchAndWorker:branchToReadingWorker) {
         if(lastBranchName != branchAndWorker.first) {
           //have to put back the period we removed earlier in order to get the proper name
           BranchID bid(branchAndWorker.first+".");
           earlyDeleteBranchToCount_.emplace_back(bid,0U);
           lastBranchName = branchAndWorker.first;
         }
         auto found = alreadySeenWorkers.find(branchAndWorker.second);
         if(alreadySeenWorkers.end() == found) {
           //NOTE: we will set aside enough space in earlyDeleteHelperToBranchIndicies_ to accommodate
           // all the branches that might be read by this worker. However, initially we will only tell the
           // EarlyDeleteHelper about the first one. As additional branches are added via 'appendIndex' the
           // EarlyDeleteHelper will automatically advance its internal end pointer.
           size_t index = nextOpenIndex;
           size_t nIndices = reserveSizeForWorker[branchAndWorker.second];
           earlyDeleteHelperToBranchIndicies_[index]=earlyDeleteBranchToCount_.size()-1;
           earlyDeleteHelpers_.emplace_back(beginAddress+index,
                                            beginAddress+index+1,
                                            &earlyDeleteBranchToCount_);
           branchAndWorker.second->setEarlyDeleteHelper(&(earlyDeleteHelpers_.back()));
           alreadySeenWorkers.insert(std::make_pair(branchAndWorker.second,&(earlyDeleteHelpers_.back())));
           nextOpenIndex +=nIndices;
         } else {
           found->second->appendIndex(earlyDeleteBranchToCount_.size()-1);
         }
       }
       
       //Now we can compactify the earlyDeleteHelperToBranchIndicies_ since we may have over estimated the
       // space needed for each module
       auto itLast = earlyDeleteHelpers_.begin();
       for(auto it = earlyDeleteHelpers_.begin()+1;it != earlyDeleteHelpers_.end();++it) {
         if(itLast->end() != it->begin()) {
           //figure the offset for next Worker since it hasn't been moved yet so it has the original address
           unsigned int delta = it->begin()- itLast->end();
           it->shiftIndexPointers(delta);
           
           earlyDeleteHelperToBranchIndicies_.erase(earlyDeleteHelperToBranchIndicies_.begin()+
                                                    (itLast->end()-beginAddress),
                                                    earlyDeleteHelperToBranchIndicies_.begin()+
                                                    (it->begin()-beginAddress));
         }
         itLast = it;
       }
       earlyDeleteHelperToBranchIndicies_.erase(earlyDeleteHelperToBranchIndicies_.begin()+(itLast->end()-beginAddress),
                                                earlyDeleteHelperToBranchIndicies_.end());
       
       //now tell the paths about the deleters
       for(auto& p : trig_paths_) {
         p.setEarlyDeleteHelpers(alreadySeenWorkers);
       }
       for(auto& p : end_paths_) {
         p.setEarlyDeleteHelpers(alreadySeenWorkers);
       }
       resetEarlyDelete();
     }
   }

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

Definition at line 709 of file StreamSchedule.cc.

References end_paths_, newFWLiteAna::found, i, and edm::Path::name().

                                                                        {
     descriptions.clear();
     bool found = false;
     TrigPaths::const_iterator itFound;
 
     if(hint < end_paths_.size()) {
       itFound = end_paths_.begin() + hint;
       if(itFound->name() == iEndPathLabel) found = true;
     }
     if(!found) {
       // if the hint did not work, do it the slow way
       itFound = std::find_if (end_paths_.begin(),
                               end_paths_.end(),
                               std::bind(std::equal_to<std::string>(),
                                         iEndPathLabel,
                                         std::bind(&Path::name, std::placeholders::_1)));
       if (itFound != end_paths_.end()) found = true;
     }
     if (found) {
       descriptions.reserve(itFound->size());
       for (size_t i = 0; i < itFound->size(); ++i) {
         descriptions.push_back(itFound->getWorker(i)->descPtr());
       }
     }
   }

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

Definition at line 680 of file StreamSchedule.cc.

References newFWLiteAna::found, i, edm::Path::name(), and trig_paths_.

                                                                     {
     descriptions.clear();
     bool found = false;
     TrigPaths::const_iterator itFound;
 
     if(hint < trig_paths_.size()) {
       itFound = trig_paths_.begin() + hint;
       if(itFound->name() == iPathLabel) found = true;
     }
     if(!found) {
       // if the hint did not work, do it the slow way
       itFound = std::find_if (trig_paths_.begin(),
                               trig_paths_.end(),
                               std::bind(std::equal_to<std::string>(),
                                         iPathLabel,
                                         std::bind(&Path::name, std::placeholders::_1)));
       if (itFound != trig_paths_.end()) found = true;
     }
     if (found) {
       descriptions.reserve(itFound->size());
       for (size_t i = 0; i < itFound->size(); ++i) {
         descriptions.push_back(itFound->getWorker(i)->descPtr());
       }
     }
   }

void edm::StreamSchedule::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 663 of file StreamSchedule.cc.

References i, edm::Path::name(), and trig_paths_.

                                                                      {
     TrigPaths::const_iterator itFound =
     std::find_if (trig_paths_.begin(),
                  trig_paths_.end(),
                  std::bind(std::equal_to<std::string>(),
                              iPathLabel,
                              std::bind(&Path::name, std::placeholders::_1)));
     if (itFound!=trig_paths_.end()) {
       oLabelsToFill.reserve(itFound->size());
       for (size_t i = 0; i < itFound->size(); ++i) {
         oLabelsToFill.push_back(itFound->getWorker(i)->description().moduleLabel());
       }
     }
   }

unsigned int edm::StreamSchedule::numberOfUnscheduledModules ( ) const

inline

Definition at line 257 of file StreamSchedule.h.

References number_of_unscheduled_modules_.

                                                     {
       return number_of_unscheduled_modules_;
     }

void edm::StreamSchedule::processOneEvent	(	EventPrincipal &	principal,
		EventSetup const &	eventSetup,
		bool	cleaningUpAfterException = `false`
	)

Definition at line 546 of file StreamSchedule.cc.

References mps_fire::action, actionTable(), actReg_, cms::Exception::addContext(), edm::addContextAndPrintException(), assert(), cms::Exception::category(), cms::Exception::context(), alignCSCRings::e, empty_trig_paths_, end_paths_, endpathsAreActive_, edm::exception_actions::FailPath, edm::ExceptionToActionTable::find(), edm::propagate_const< T >::get(), edm::exception_actions::IgnoreCompletely, edm::make_empty_waiting_task(), edm::hlt::Pass, edm::printCmsExceptionWarning(), edm::WorkerManager::processOneOccurrence(), resetAll(), resetEarlyDelete(), results_, results_inserter_, edm::exception_actions::SkipEvent, streamContext_, streamID_, total_events_, total_passed_, trig_paths_, workerManager_, and edm::convertException::wrap().

                                                                       {
     this->resetAll();
     for (int empty_trig_path : empty_trig_paths_) {
       results_->at(empty_trig_path) = HLTPathStatus(hlt::Pass, 0);
     }
     
     using Traits = OccurrenceTraits<EventPrincipal, BranchActionStreamBegin>;
     
     Traits::setStreamContext(streamContext_, ep);
     StreamScheduleSignalSentry<Traits> sentry(actReg_.get(), &streamContext_);
     
     SendTerminationSignalIfException terminationSentry(actReg_.get(), &streamContext_);
     // This call takes care of the unscheduled processing.
     workerManager_.processOneOccurrence<Traits>(ep, es, streamID_, &streamContext_, &streamContext_, cleaningUpAfterException);
     
     ++total_events_;
     try {
       convertException::wrap([&]() {
         
         try {
           auto waitTask = edm::make_empty_waiting_task();
           //set count to 2 since wait_for_all requires value to not go to 0
           waitTask->set_ref_count(2);
           //Begin process in reverse order since TBB is last in first out for tasks.
           for(auto it = trig_paths_.rbegin(), itEnd = trig_paths_.rend();
               it != itEnd; ++ it) {
             it->processOneOccurrenceAsync(waitTask.get(),ep, es, streamID_, &streamContext_);
           }
           waitTask->decrement_ref_count();
           waitTask->wait_for_all();
           
           if(waitTask->exceptionPtr() != nullptr) {
             std::rethrow_exception(*(waitTask->exceptionPtr()));
           }
           if(results_->accept()) {
             ++total_passed_;
           }
 
         }
         catch(cms::Exception& e) {
           exception_actions::ActionCodes action = actionTable().find(e.category());
           assert (action != exception_actions::IgnoreCompletely);
           assert (action != exception_actions::FailPath);
           if (action == exception_actions::SkipEvent) {
             edm::printCmsExceptionWarning("SkipEvent", e);
           } else {
             throw;
           }
         }
         
         try {
           ParentContext parentContext(&streamContext_);
           if (results_inserter_.get()) results_inserter_->doWork<Traits>(ep, es, streamID_, parentContext, &streamContext_);
         }
         catch (cms::Exception & ex) {
           ex.addContext("Calling produce method for module TriggerResultInserter");
           std::ostringstream ost;
           ost << "Processing " << ep.id();
           ex.addContext(ost.str());
           throw;
         }
         
         if (endpathsAreActive_) {
           auto waitTask = edm::make_empty_waiting_task();
           //set count to 2 since wait_for_all requires value to not go to 0
           waitTask->set_ref_count(2);
           for(auto it = end_paths_.rbegin(), itEnd = end_paths_.rend();
               it != itEnd; ++it) {
             it->processOneOccurrenceAsync(waitTask.get(),ep, es, streamID_, &streamContext_);
           }
           waitTask->decrement_ref_count();
           waitTask->wait_for_all();
           
           if(waitTask->exceptionPtr() != nullptr) {
             std::rethrow_exception(*(waitTask->exceptionPtr()));
           }
 
         }
         resetEarlyDelete();
       });
     }
     catch(cms::Exception& ex) {
       if (ex.context().empty()) {
         addContextAndPrintException("Calling function StreamSchedule::processOneEvent", ex, cleaningUpAfterException);
       } else {
         addContextAndPrintException("", ex, cleaningUpAfterException);
       }
       throw;
     }
     terminationSentry.completedSuccessfully();
     
     //If we got here no other exception has happened so we can propogate any Service related exceptions
     sentry.allowThrow();
   }

template<typename T >

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

Definition at line 376 of file StreamSchedule.h.

References actReg_, edm::addContextAndPrintException(), cms::Exception::context(), endpathsAreActive_, edm::WorkerManager::processOneOccurrence(), resetAll(), streamContext_, streamID_, workerManager_, and edm::convertException::wrap().

                                                                  {
     this->resetAll();
 
     T::setStreamContext(streamContext_, ep);
     StreamScheduleSignalSentry<T> sentry(actReg_.get(), &streamContext_);
 
     SendTerminationSignalIfException terminationSentry(actReg_.get(), &streamContext_);
 
     // This call takes care of the unscheduled processing.
     workerManager_.processOneOccurrence<T>(ep, es, streamID_, &streamContext_, &streamContext_, cleaningUpAfterException);
 
     try {
       convertException::wrap([&]() {
         runTriggerPaths<T>(ep, es, &streamContext_);
 
         if (endpathsAreActive_) runEndPaths<T>(ep, es, &streamContext_);
       });
     }
     catch(cms::Exception& ex) {
       if (ex.context().empty()) {
         addContextAndPrintException("Calling function StreamSchedule::processOneStream", ex, cleaningUpAfterException);
       } else {
         addContextAndPrintException("", ex, cleaningUpAfterException);
       }
       throw;
     }
     terminationSentry.completedSuccessfully();
 
     //If we got here no other exception has happened so we can propogate any Service related exceptions
     sentry.allowThrow();
   }

void edm::StreamSchedule::replaceModule	(	maker::ModuleHolder *	iMod,
		std::string const &	iLabel
	)

clone the type of module with label iLabel but configure with iPSet.

Definition at line 517 of file StreamSchedule.cc.

References allWorkers(), edm::Worker::beginStream(), newFWLiteAna::found, edm::maker::ModuleHolder::replaceModuleFor(), streamContext_, and streamID_.

                                                              {
     Worker* found = nullptr;
     for (auto const& worker : allWorkers()) {
       if (worker->description().moduleLabel() == iLabel) {
         found = worker;
         break;
       }
     }
     if (nullptr == found) {
       return;
     }
 
     iMod->replaceModuleFor(found);
     found->beginStream(streamID_,streamContext_);
   }

void edm::StreamSchedule::reportSkipped ( EventPrincipal const & ep ) const

inlineprivate

Definition at line 370 of file StreamSchedule.h.

References edm::EventID::event(), edm::EventPrincipal::id(), and edm::EventID::run().

                                                               {
     Service<JobReport> reportSvc;
     reportSvc->reportSkippedEvent(ep.id().run(), ep.id().event());
   }

void edm::StreamSchedule::resetAll ( )

private

Definition at line 819 of file StreamSchedule.cc.

References results_, and skippingEvent_.

Referenced by processOneEvent(), and processOneStream().

                            {
     skippingEvent_ = false;
     results_->reset();
   }

void edm::StreamSchedule::resetEarlyDelete ( )

private

Definition at line 830 of file StreamSchedule.cc.

References KineDebug3::count(), earlyDeleteBranchToCount_, earlyDeleteHelpers_, earlyDeleteHelperToBranchIndicies_, and cmsHarvester::index.

Referenced by initializeEarlyDelete(), and processOneEvent().

                                    {
     //must be sure we have cleared the count first
     for(auto& count:earlyDeleteBranchToCount_) {
       count.count = 0;
     }
     //now reset based on how many helpers use that branch
     for(auto& index: earlyDeleteHelperToBranchIndicies_) {
       ++(earlyDeleteBranchToCount_[index].count);
     }
     for(auto& helper: earlyDeleteHelpers_) {
       helper.reset();
     }
   }

TrigResConstPtr edm::StreamSchedule::results ( ) const

inlineprivate

Definition at line 326 of file StreamSchedule.h.

References edm::get_underlying_safe(), and results_.

Referenced by StreamSchedule().

326 {return get_underlying_safe(results_);}

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:39

edm::StreamSchedule::results_

edm::propagate_const< TrigResPtr > results_

Definition: StreamSchedule.h:335

TrigResPtr& edm::StreamSchedule::results ( )

inlineprivate

Definition at line 327 of file StreamSchedule.h.

References edm::get_underlying_safe(), and results_.

327 {return get_underlying_safe(results_);}

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:39

edm::StreamSchedule::results_

edm::propagate_const< TrigResPtr > results_

Definition: StreamSchedule.h:335

template<typename T >

void edm::StreamSchedule::runEndPaths	(	typename T::MyPrincipal const &	ep,
		EventSetup const &	es,
		typename T::Context const *	context
	)

private

Definition at line 421 of file StreamSchedule.h.

References end_paths_, AlCaHLTBitMon_ParallelJobs::p, and streamID_.

                                                                                                                      {
     // Note there is no state-checking safety controlling the
     // activation/deactivation of endpaths.
     for(auto& p : end_paths_) {
       p.processOneOccurrence<T>(ep, es, streamID_, context);
     }
   }

template<typename T >

bool edm::StreamSchedule::runTriggerPaths	(	typename T::MyPrincipal const &	ep,
		EventSetup const &	es,
		typename T::Context const *	context
	)

private

Definition at line 412 of file StreamSchedule.h.

References AlCaHLTBitMon_ParallelJobs::p, results_, streamID_, and trig_paths_.

                                                                                                                          {
     for(auto& p : trig_paths_) {
       p.processOneOccurrence<T>(ep, es, streamID_, context);
     }
     return results_->accept();
   }

StreamID edm::StreamSchedule::streamID ( ) const

inline

Definition at line 182 of file StreamSchedule.h.

References streamID_.

182 { return streamID_; }

edm::StreamSchedule::streamID_

StreamID streamID_

Definition: StreamSchedule.h:362

int edm::StreamSchedule::totalEvents ( ) const

inline

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

Definition at line 218 of file StreamSchedule.h.

References total_events_.

Referenced by getTriggerReport(), and totalEventsFailed().

                             {
       return total_events_;
     }

int edm::StreamSchedule::totalEventsFailed ( ) const

inline

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

Definition at line 230 of file StreamSchedule.h.

References totalEvents(), and totalEventsPassed().

Referenced by getTriggerReport().

                                   {
       return totalEvents() - totalEventsPassed();
     }

int edm::StreamSchedule::totalEventsPassed ( ) const

inline

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

Definition at line 224 of file StreamSchedule.h.

References total_passed_.

Referenced by getTriggerReport(), and totalEventsFailed().

                                   {
       return total_passed_;
     }

void edm::StreamSchedule::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 so matches the entries in TriggerResults exactly.

Definition at line 653 of file StreamSchedule.cc.

References trig_name_list_.

                                                                         {
     oLabelsToFill = trig_name_list_;
   }

Member Data Documentation

std::shared_ptr<ActivityRegistry> edm::StreamSchedule::actReg_

private

Definition at line 330 of file StreamSchedule.h.

Referenced by fillEndPath(), fillTrigPath(), processOneEvent(), processOneStream(), and StreamSchedule().

std::vector<BranchToCount> edm::StreamSchedule::earlyDeleteBranchToCount_

private

Definition at line 346 of file StreamSchedule.h.

Referenced by initializeEarlyDelete(), and resetEarlyDelete().

std::vector<EarlyDeleteHelper> edm::StreamSchedule::earlyDeleteHelpers_

private

Definition at line 356 of file StreamSchedule.h.

Referenced by initializeEarlyDelete(), and resetEarlyDelete().

std::vector<unsigned int> edm::StreamSchedule::earlyDeleteHelperToBranchIndicies_

private

Definition at line 353 of file StreamSchedule.h.

Referenced by initializeEarlyDelete(), and resetEarlyDelete().

vstring edm::StreamSchedule::empty_trig_path_names_

private

Definition at line 341 of file StreamSchedule.h.

Referenced by fillTrigPath().

std::vector<int> edm::StreamSchedule::empty_trig_paths_

private

Definition at line 340 of file StreamSchedule.h.

Referenced by fillTrigPath(), and processOneEvent().

vstring edm::StreamSchedule::end_path_name_list_

private

Definition at line 333 of file StreamSchedule.h.

Referenced by endPaths(), fillWorkers(), and StreamSchedule().

TrigPaths edm::StreamSchedule::end_paths_

private

Definition at line 339 of file StreamSchedule.h.

Referenced by clearCounters(), fillEndPath(), getTriggerReport(), initializeEarlyDelete(), moduleDescriptionsInEndPath(), processOneEvent(), runEndPaths(), and StreamSchedule().

volatile bool edm::StreamSchedule::endpathsAreActive_

private

Definition at line 364 of file StreamSchedule.h.

Referenced by enableEndPaths(), endPathsEnabled(), processOneEvent(), and processOneStream().

unsigned int edm::StreamSchedule::number_of_unscheduled_modules_

private

Definition at line 360 of file StreamSchedule.h.

Referenced by numberOfUnscheduledModules(), and StreamSchedule().

edm::propagate_const<TrigResPtr> edm::StreamSchedule::results_

private

Definition at line 335 of file StreamSchedule.h.

Referenced by processOneEvent(), resetAll(), results(), and runTriggerPaths().

edm::propagate_const<WorkerPtr> edm::StreamSchedule::results_inserter_

private

Definition at line 337 of file StreamSchedule.h.

Referenced by processOneEvent(), and StreamSchedule().

std::atomic<bool> edm::StreamSchedule::skippingEvent_

private

Definition at line 365 of file StreamSchedule.h.

Referenced by fillTrigPath(), and resetAll().

StreamContext edm::StreamSchedule::streamContext_

private

Definition at line 363 of file StreamSchedule.h.

Referenced by beginStream(), endStream(), fillEndPath(), fillTrigPath(), processOneEvent(), processOneStream(), and replaceModule().

StreamID edm::StreamSchedule::streamID_

private

Definition at line 362 of file StreamSchedule.h.

Referenced by beginStream(), endStream(), processOneEvent(), processOneStream(), replaceModule(), runEndPaths(), runTriggerPaths(), and streamID().

int edm::StreamSchedule::total_events_

private

Definition at line 358 of file StreamSchedule.h.

Referenced by clearCounters(), processOneEvent(), and totalEvents().

int edm::StreamSchedule::total_passed_

private

Definition at line 359 of file StreamSchedule.h.

Referenced by clearCounters(), processOneEvent(), and totalEventsPassed().

vstring edm::StreamSchedule::trig_name_list_

private

Definition at line 332 of file StreamSchedule.h.

Referenced by StreamSchedule(), and triggerPaths().

TrigPaths edm::StreamSchedule::trig_paths_

private

Definition at line 338 of file StreamSchedule.h.

Referenced by availablePaths(), clearCounters(), fillTrigPath(), getTriggerReport(), initializeEarlyDelete(), moduleDescriptionsInPath(), modulesInPath(), processOneEvent(), runTriggerPaths(), and StreamSchedule().

WorkerManager edm::StreamSchedule::workerManager_

private

Definition at line 329 of file StreamSchedule.h.

Referenced by actionTable(), addToAllWorkers(), allWorkers(), beginStream(), endStream(), fillWorkers(), processOneEvent(), processOneStream(), and StreamSchedule().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation