edm::Schedule Class Reference

#include <Schedule.h>

Public Types
typedef std::vector < OutputWorker * >	AllOutputWorkers
typedef std::vector< Worker * >	AllWorkers
typedef std::vector< Path >	NonTrigPaths
typedef std::vector< WorkerInPath >	PathWorkers
enum	State { Ready = 0, Running, Latched }
typedef std::vector< Path >	TrigPaths
typedef boost::shared_ptr < HLTGlobalStatus >	TrigResPtr
typedef std::vector< std::string >	vstring
typedef boost::shared_ptr< Worker >	WorkerPtr
typedef std::vector< Worker * >	Workers

Public Member Functions
void	availablePaths (std::vector< std::string > &oLabelsToFill) const
	adds to oLabelsToFill the labels for all paths in the process More...
void	beginJob ()
bool	changeModule (std::string const &iLabel, ParameterSet const &iPSet)
void	clearCounters ()
	Clear all the counters in the trigger report. More...
void	closeOutputFiles ()
void	enableEndPaths (bool active)
void	endJob (ExceptionCollector &collector)
bool	endPathsEnabled () const
std::vector< ModuleDescription const * >	getAllModuleDescriptions () const
void	getTriggerReport (TriggerReport &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	processOneOccurrence (typename T::MyPrincipal &principal, EventSetup const &eventSetup, bool cleaningUpAfterException=false)
void	respondToCloseInputFile (FileBlock const &fb)
void	respondToCloseOutputFiles (FileBlock const &fb)
void	respondToOpenInputFile (FileBlock const &fb)
void	respondToOpenOutputFiles (FileBlock const &fb)
	Schedule (ParameterSet &proc_pset, service::TriggerNamesService &tns, ProductRegistry &pregistry, ActionTable const &actions, boost::shared_ptr< ActivityRegistry > areg, boost::shared_ptr< ProcessConfiguration > processConfiguration, const ParameterSet *subProcPSet)
bool	shouldWeCloseOutput () const
bool	terminate () const
	Return whether each output module has reached its maximum count. More...
std::pair< double, double >	timeCpuReal () const
int	totalEvents () const
int	totalEventsFailed () const
int	totalEventsPassed () const
void	writeLumi (LuminosityBlockPrincipal const &lbp)
void	writeRun (RunPrincipal const &rp)

Private Member Functions
void	addToAllWorkers (Worker *w)
void	fillEndPath (ParameterSet &proc_pset, ProductRegistry &preg, boost::shared_ptr< ProcessConfiguration const > processConfiguration, int bitpos, std::string const &name)
void	fillTrigPath (ParameterSet &proc_pset, ProductRegistry &preg, boost::shared_ptr< ProcessConfiguration const > processConfiguration, int bitpos, std::string const &name, TrigResPtr, vstring *labelsOnTriggerPaths)
void	fillWorkers (ParameterSet &proc_pset, ProductRegistry &preg, boost::shared_ptr< ProcessConfiguration const > processConfiguration, std::string const &name, bool ignoreFilters, PathWorkers &out, vstring *labelsOnPaths)
void	initializeEarlyDelete (edm::ParameterSet const &opts, edm::ProductRegistry const &preg, edm::ParameterSet const *subProcPSet)
void	limitOutput (ParameterSet const &proc_pset)
void	reduceParameterSet (ParameterSet &proc_pset, vstring &modulesInConfig, std::set< std::string > const &modulesInConfigSet, vstring &labelsOnTriggerPaths, vstring &shouldBeUsedLabels, std::map< std::string, std::vector< std::pair< std::string, int > > > &outputModulePathPositions)
void	reportSkipped (EventPrincipal const &ep) const
void	reportSkipped (LuminosityBlockPrincipal const &) const
void	reportSkipped (RunPrincipal const &) const
void	resetAll ()
void	resetEarlyDelete ()
template<typename T >
void	runEndPaths (typename T::MyPrincipal &, EventSetup const &)
template<typename T >
bool	runTriggerPaths (typename T::MyPrincipal &, EventSetup const &)
void	setupOnDemandSystem (EventPrincipal &principal, EventSetup const &es)
AllWorkers::const_iterator	workersBegin () const
AllWorkers::iterator	workersBegin ()
AllWorkers::const_iterator	workersEnd () const
AllWorkers::iterator	workersEnd ()

Private Attributes
ActionTable const *	act_table_
boost::shared_ptr < ActivityRegistry >	actReg_
AllOutputWorkers	all_output_workers_
AllWorkers	all_workers_
std::vector< std::pair < BranchID, unsigned int > >	earlyDeleteBranchToCount_
std::vector< EarlyDeleteHelper >	earlyDeleteHelpers_
std::vector< unsigned int >	earlyDeleteHelperToBranchIndicies_
vstring	end_path_name_list_
TrigPaths	end_paths_
TrigResPtr	endpath_results_
volatile bool	endpathsAreActive_
TrigResPtr	results_
WorkerPtr	results_inserter_
State	state_
RunStopwatch::StopwatchPointer	stopwatch_
int	total_events_
int	total_passed_
vstring	trig_name_list_
TrigPaths	trig_paths_
boost::shared_ptr < UnscheduledCallProducer >	unscheduled_
bool	wantSummary_
WorkerRegistry	worker_reg_

Detailed Description

Definition at line 102 of file Schedule.h.

Member Typedef Documentation

typedef std::vector<OutputWorker*> edm::Schedule::AllOutputWorkers

Definition at line 110 of file Schedule.h.

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

Definition at line 109 of file Schedule.h.

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

Definition at line 106 of file Schedule.h.

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

Definition at line 114 of file Schedule.h.

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

Definition at line 105 of file Schedule.h.

typedef boost::shared_ptr<HLTGlobalStatus> edm::Schedule::TrigResPtr

Definition at line 107 of file Schedule.h.

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

Definition at line 104 of file Schedule.h.

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

Definition at line 108 of file Schedule.h.

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

Definition at line 112 of file Schedule.h.

Member Enumeration Documentation

enum edm::Schedule::State

Enumerator
Ready
Running
Latched

Definition at line 124 of file Schedule.h.

{ Ready = 0, Running, Latched };

Constructor & Destructor Documentation

edm::Schedule::Schedule	(	ParameterSet &	proc_pset,
		service::TriggerNamesService &	tns,
		ProductRegistry &	pregistry,
		ActionTable const &	actions,
		boost::shared_ptr< ActivityRegistry >	areg,
		boost::shared_ptr< ProcessConfiguration >	processConfiguration,
		const ParameterSet *	subProcPSet
	)

Definition at line 151 of file Schedule.cc.

References act_table_, actReg_, addToAllWorkers(), all_output_workers_, all_workers_, edm::ProductRegistry::anyProductProduced(), alignCSCRings::e, end_path_name_list_, endpath_results_, edm::detail::ThreadSafeRegistry< KEY, T, E >::extra(), fillEndPath(), edm::fillProductRegistryTransients(), fillTrigPath(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), edm::WorkerRegistry::getWorker(), i, edm::ParameterSet::id(), edm::InEvent, initializeEarlyDelete(), edm::detail::ThreadSafeRegistry< KEY, T, E >::insertMapped(), edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), limitOutput(), edm::loadMissingDictionaries(), geometryDiff::opts, edm::ProductRegistry::productList(), reduceParameterSet(), edm::ParameterSet::registerIt(), results_, results_inserter_, edm::ProductRegistry::setFrozen(), trig_name_list_, unscheduled_, edm::BranchIDListHelper::updateRegistries(), worker_reg_, workersBegin(), and workersEnd().

                                                      :
    worker_reg_(areg),
    act_table_(&actions),
    actReg_(areg),
    state_(Ready),
    trig_name_list_(tns.getTrigPaths()),
    end_path_name_list_(tns.getEndPaths()),
    results_(new HLTGlobalStatus(trig_name_list_.size())),
    endpath_results_(), // delay!
    results_inserter_(),
    all_workers_(),
    all_output_workers_(),
    trig_paths_(),
    end_paths_(),
    wantSummary_(tns.wantSummary()),
    total_events_(),
    total_passed_(),
    stopwatch_(wantSummary_? new RunStopwatch::StopwatchPointer::element_type : static_cast<RunStopwatch::StopwatchPointer::element_type*> (0)),
    unscheduled_(new UnscheduledCallProducer),
    endpathsAreActive_(true) {

    ParameterSet const& opts = proc_pset.getUntrackedParameterSet("options", ParameterSet());
    bool hasPath = false;

    int trig_bitpos = 0;
    vstring labelsOnTriggerPaths;
    for (vstring::const_iterator i = trig_name_list_.begin(),
           e = trig_name_list_.end();
         i != e;
         ++i) {
      fillTrigPath(proc_pset, preg, processConfiguration, trig_bitpos, *i, results_, &labelsOnTriggerPaths);
      ++trig_bitpos;
      hasPath = true;
    }

    if (hasPath) {
      // the results inserter stands alone
      results_inserter_ = makeInserter(proc_pset,
                                       preg,
                                       actions, actReg_, processConfiguration, results_);
      addToAllWorkers(results_inserter_.get());
    }

    TrigResPtr epptr(new HLTGlobalStatus(end_path_name_list_.size()));
    endpath_results_ = epptr;

    // fill normal endpaths
    vstring::iterator eib(end_path_name_list_.begin()), eie(end_path_name_list_.end());
    for (int bitpos = 0; eib != eie; ++eib, ++bitpos) {
      fillEndPath(proc_pset, preg, processConfiguration, bitpos, *eib);
    }

    //See if all modules were used
    std::set<std::string> usedWorkerLabels;
    for (AllWorkers::iterator itWorker = workersBegin();
        itWorker != workersEnd();
        ++itWorker) {
      usedWorkerLabels.insert((*itWorker)->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 (std::vector<std::string>::iterator itLabel = unusedLabels.begin(), itLabelEnd = unusedLabels.end();
          itLabel != itLabelEnd;
          ++itLabel) {
        if (allowUnscheduled) {
          bool isTracked;
          ParameterSet* modulePSet(proc_pset.getPSetForUpdate(*itLabel, isTracked));
          assert(isTracked);
          assert(modulePSet != 0);
          WorkerParams params(proc_pset, modulePSet, preg,
                              processConfiguration, *act_table_);
          Worker* newWorker(worker_reg_.getWorker(params, *itLabel));
          if (dynamic_cast<WorkerT<EDProducer>*>(newWorker) ||
              dynamic_cast<WorkerT<EDFilter>*>(newWorker)) {
            unscheduledLabels.insert(*itLabel);
            unscheduled_->addWorker(newWorker);
            //add to list so it gets reset each new event
            addToAllWorkers(newWorker);
          } else {
            //not a producer so should be marked as not used
            shouldBeUsedLabels.push_back(*itLabel);
          }
        } else {
          //everthing is marked are unused so no 'on demand' allowed
          shouldBeUsedLabels.push_back(*itLabel);
        }
      }
      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()) {
      for (ProductRegistry::ProductList::const_iterator it = preg.productList().begin(),
          itEnd = preg.productList().end();
          it != itEnd;
          ++it) {
        if (it->second.produced() &&
            it->second.branchType() == InEvent &&
            unscheduledLabels.end() != unscheduledLabels.find(it->second.moduleLabel())) {
          it->second.setOnDemand();
        }
      }
    }

    std::map<std::string, std::vector<std::pair<std::string, int> > > outputModulePathPositions;
    reduceParameterSet(proc_pset, modulesInConfig, modulesInConfigSet, labelsOnTriggerPaths, shouldBeUsedLabels, outputModulePathPositions);

    proc_pset.registerIt();
    pset::Registry::instance()->extra().setID(proc_pset.id());
    processConfiguration->setParameterSetID(proc_pset.id());

    initializeEarlyDelete(opts,preg,subProcPSet);
    
    // This is used for a little sanity-check to make sure no code
    // modifications alter the number of workers at a later date.
    size_t all_workers_count = all_workers_.size();

    for (AllWorkers::iterator i = all_workers_.begin(), e = all_workers_.end();
         i != e;
         ++i) {

      // All the workers should be in all_workers_ by this point. Thus
      // we can now fill all_output_workers_.
      OutputWorker* ow = dynamic_cast<OutputWorker*>(*i);
      if (ow) {
        all_output_workers_.push_back(ow);
      }
    }
    // Now that the output workers are filled in, set any output limits.
    limitOutput(proc_pset);

    loadMissingDictionaries();
    preg.setFrozen();

    for (AllOutputWorkers::iterator i = all_output_workers_.begin(), e = all_output_workers_.end();
         i != e; ++i) {
      (*i)->setEventSelectionInfo(outputModulePathPositions, preg.anyProductProduced());
    }

    // Sanity check: make sure nobody has added a worker after we've
    // already relied on all_workers_ being full.
    assert (all_workers_count == all_workers_.size());

    ProcessConfigurationRegistry::instance()->insertMapped(*processConfiguration);
    BranchIDListHelper::updateRegistries(preg);
    fillProductRegistryTransients(*processConfiguration, preg);
  } // Schedule::Schedule

Member Function Documentation

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

private

Definition at line 1318 of file Schedule.cc.

References all_workers_, edm::search_all(), edm::Worker::useStopwatch(), and wantSummary_.

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

                                     {
    if (!search_all(all_workers_, w)) {
      if (wantSummary_) {
        w->useStopwatch();
      }
      all_workers_.push_back(w);
    }
  }

void edm::Schedule::availablePaths

(

std::vector< std::string > &

oLabelsToFill

)

const

adds to oLabelsToFill the labels for all paths in the process

Definition at line 1209 of file Schedule.cc.

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

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

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

void edm::Schedule::beginJob

(

void

)

Definition at line 1161 of file Schedule.cc.

References all_workers_, edm::Worker::beginJob(), edm::for_all(), and edm::loadMissingDictionaries().

                          {
    for_all(all_workers_, boost::bind(&Worker::beginJob, _1));
    loadMissingDictionaries();
  }

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

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

Definition at line 1173 of file Schedule.cc.

References all_workers_, edm::Worker::beginJob(), SurfaceDeformationFactory::create(), edm::Worker::description(), newFWLiteAna::found, reco::get(), and edm::ModuleDescription::moduleName().

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

                                                         {
    Worker* found = 0;
    for (AllWorkers::const_iterator it=all_workers_.begin(), itEnd=all_workers_.end();
        it != itEnd; ++it) {
      if ((*it)->description().moduleLabel() == iLabel) {
        found = *it;
        break;
      }
    }
    if (0 == found) {
      return false;
    }

    std::auto_ptr<Maker> wm(MakerPluginFactory::get()->create(found->description().moduleName()));
    wm->swapModule(found, iPSet);
    found->beginJob();
    return true;
  }

void edm::Schedule::clearCounters

(

)

Clear all the counters in the trigger report.

Definition at line 1303 of file Schedule.cc.

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

                          {
    total_events_ = total_passed_ = 0;
    for_all(trig_paths_, boost::bind(&Path::clearCounters, _1));
    for_all(end_paths_, boost::bind(&Path::clearCounters, _1));
    for_all(all_workers_, boost::bind(&Worker::clearCounters, _1));
  }

void edm::Schedule::closeOutputFiles

(

)

Definition at line 1118 of file Schedule.cc.

References all_output_workers_, edm::OutputWorker::closeFile(), and edm::for_all().

                                  {
    for_all(all_output_workers_, boost::bind(&OutputWorker::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 1235 of file Schedule.cc.

References endpathsAreActive_.

                                      {
    endpathsAreActive_ = active;
  }

void edm::Schedule::endJob

(

ExceptionCollector &

collector

)

Definition at line 767 of file Schedule.cc.

References edm::ExceptionCollector::addException(), edm::convertException::badAllocToEDM(), trackerHits::c, edm::convertException::charPtrToEDM(), alignCSCRings::e, end_paths_, cppFunctionSkipper::exception, i, max(), pi, edm::convertException::stdToEDM(), edm::convertException::stringToEDM(), timeCpuReal(), totalEvents(), totalEventsFailed(), totalEventsPassed(), trig_paths_, edm::convertException::unknownToEDM(), wantSummary_, workersBegin(), and workersEnd().

                                                      {
    bool failure = false;
    AllWorkers::iterator ai(workersBegin()), ae(workersEnd());
    for (; ai != ae; ++ai) {
      try {
        try {
          (*ai)->endJob();
        }
        catch (cms::Exception& e) { throw; }
        catch (std::bad_alloc& bda) { convertException::badAllocToEDM(); }
        catch (std::exception& e) { convertException::stdToEDM(e); }
        catch (std::string& s) { convertException::stringToEDM(s); }
        catch (char const* c) { convertException::charPtrToEDM(c); }
        catch (...) { convertException::unknownToEDM(); }
      }      
      catch (cms::Exception const& ex) {
        collector.addException(ex);
        failure = true;
      }
    }
    if (failure) {
      return;
    }

    if (wantSummary_ == false) return;

    TrigPaths::const_iterator pi, pe;

    // The trigger report (pass/fail etc.):

    LogVerbatim("FwkSummary") << "";
    LogVerbatim("FwkSummary") << "TrigReport " << "---------- Event  Summary ------------";
    LogVerbatim("FwkSummary") << "TrigReport"
                              << " Events total = " << totalEvents()
                              << " passed = " << totalEventsPassed()
                              << " failed = " << (totalEventsFailed())
                              << "";

    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" << "";
    pi = trig_paths_.begin();
    pe = trig_paths_.end();
    for (; pi != pe; ++pi) {
      LogVerbatim("FwkSummary") << "TrigReport "
                                << std::right << std::setw(5) << 1
                                << std::right << std::setw(5) << pi->bitPosition() << " "
                                << std::right << std::setw(10) << pi->timesRun() << " "
                                << std::right << std::setw(10) << pi->timesPassed() << " "
                                << std::right << std::setw(10) << pi->timesFailed() << " "
                                << std::right << std::setw(10) << pi->timesExcept() << " "
                                << pi->name() << "";
    }

    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" << "";
    pi = end_paths_.begin();
    pe = end_paths_.end();
    for (; pi != pe; ++pi) {
      LogVerbatim("FwkSummary") << "TrigReport "
                                << std::right << std::setw(5) << 0
                                << std::right << std::setw(5) << pi->bitPosition() << " "
                                << std::right << std::setw(10) << pi->timesRun() << " "
                                << std::right << std::setw(10) << pi->timesPassed() << " "
                                << std::right << std::setw(10) << pi->timesFailed() << " "
                                << std::right << std::setw(10) << pi->timesExcept() << " "
                                << pi->name() << "";
    }

    pi = trig_paths_.begin();
    pe = trig_paths_.end();
    for (; pi != pe; ++pi) {
      LogVerbatim("FwkSummary") << "";
      LogVerbatim("FwkSummary") << "TrigReport " << "---------- Modules in Path: " << pi->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" << "";

      for (unsigned int i = 0; i < pi->size(); ++i) {
        LogVerbatim("FwkSummary") << "TrigReport "
                                  << std::right << std::setw(5) << 1
                                  << std::right << std::setw(5) << pi->bitPosition() << " "
                                  << std::right << std::setw(10) << pi->timesVisited(i) << " "
                                  << std::right << std::setw(10) << pi->timesPassed(i) << " "
                                  << std::right << std::setw(10) << pi->timesFailed(i) << " "
                                  << std::right << std::setw(10) << pi->timesExcept(i) << " "
                                  << pi->getWorker(i)->description().moduleLabel() << "";
      }
    }

    pi = end_paths_.begin();
    pe = end_paths_.end();
    for (; pi != pe; ++pi) {
      LogVerbatim("FwkSummary") << "";
      LogVerbatim("FwkSummary") << "TrigReport " << "------ Modules in End-Path: " << pi->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" << "";

      for (unsigned int i = 0; i < pi->size(); ++i) {
        LogVerbatim("FwkSummary") << "TrigReport "
                                  << std::right << std::setw(5) << 0
                                  << std::right << std::setw(5) << pi->bitPosition() << " "
                                  << std::right << std::setw(10) << pi->timesVisited(i) << " "
                                  << std::right << std::setw(10) << pi->timesPassed(i) << " "
                                  << std::right << std::setw(10) << pi->timesFailed(i) << " "
                                  << std::right << std::setw(10) << pi->timesExcept(i) << " "
                                  << pi->getWorker(i)->description().moduleLabel() << "";
      }
    }

    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" << "";
    ai = workersBegin();
    ae = workersEnd();
    for (; ai != ae; ++ai) {
      LogVerbatim("FwkSummary") << "TrigReport "
                                << std::right << std::setw(10) << (*ai)->timesVisited() << " "
                                << std::right << std::setw(10) << (*ai)->timesRun() << " "
                                << std::right << std::setw(10) << (*ai)->timesPassed() << " "
                                << std::right << std::setw(10) << (*ai)->timesFailed() << " "
                                << std::right << std::setw(10) << (*ai)->timesExcept() << " "
                                << (*ai)->description().moduleLabel() << "";

    }
    LogVerbatim("FwkSummary") << "";

    // The timing report (CPU and Real Time):

    LogVerbatim("FwkSummary") << "TimeReport " << "---------- Event  Summary ---[sec]----";
    LogVerbatim("FwkSummary") << "TimeReport"
                              << std::setprecision(6) << std::fixed
                              << " CPU/event = " << timeCpuReal().first/std::max(1, totalEvents())
                              << " Real/event = " << timeCpuReal().second/std::max(1, 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" << "";
    pi = trig_paths_.begin();
    pe = trig_paths_.end();
    for (; pi != pe; ++pi) {
      LogVerbatim("FwkSummary") << "TimeReport "
                                << std::setprecision(6) << std::fixed
                                << std::right << std::setw(10) << pi->timeCpuReal().first/std::max(1, totalEvents()) << " "
                                << std::right << std::setw(10) << pi->timeCpuReal().second/std::max(1, totalEvents()) << " "
                                << std::right << std::setw(10) << pi->timeCpuReal().first/std::max(1, pi->timesRun()) << " "
                                << std::right << std::setw(10) << pi->timeCpuReal().second/std::max(1, pi->timesRun()) << " "
                                << pi->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" << "";
    pi = end_paths_.begin();
    pe = end_paths_.end();
    for (; pi != pe; ++pi) {
      LogVerbatim("FwkSummary") << "TimeReport "
                                << std::setprecision(6) << std::fixed
                                << std::right << std::setw(10) << pi->timeCpuReal().first/std::max(1, totalEvents()) << " "
                                << std::right << std::setw(10) << pi->timeCpuReal().second/std::max(1, totalEvents()) << " "
                                << std::right << std::setw(10) << pi->timeCpuReal().first/std::max(1, pi->timesRun()) << " "
                                << std::right << std::setw(10) << pi->timeCpuReal().second/std::max(1, pi->timesRun()) << " "
                                << pi->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 "
                              << "";

    pi = trig_paths_.begin();
    pe = trig_paths_.end();
    for (; pi != pe; ++pi) {
      LogVerbatim("FwkSummary") << "";
      LogVerbatim("FwkSummary") << "TimeReport " << "---------- Modules in Path: " << pi->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 (unsigned int i = 0; i < pi->size(); ++i) {
        LogVerbatim("FwkSummary") << "TimeReport "
                                  << std::setprecision(6) << std::fixed
                                  << std::right << std::setw(10) << pi->timeCpuReal(i).first/std::max(1, totalEvents()) << " "
                                  << std::right << std::setw(10) << pi->timeCpuReal(i).second/std::max(1, totalEvents()) << " "
                                  << std::right << std::setw(10) << pi->timeCpuReal(i).first/std::max(1, pi->timesVisited(i)) << " "
                                  << std::right << std::setw(10) << pi->timeCpuReal(i).second/std::max(1, pi->timesVisited(i)) << " "
                                  << pi->getWorker(i)->description().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 "
                              << "";

    pi = end_paths_.begin();
    pe = end_paths_.end();
    for (; pi != pe; ++pi) {
      LogVerbatim("FwkSummary") << "";
      LogVerbatim("FwkSummary") << "TimeReport " << "------ Modules in End-Path: " << pi->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 (unsigned int i = 0; i < pi->size(); ++i) {
        LogVerbatim("FwkSummary") << "TimeReport "
                                  << std::setprecision(6) << std::fixed
                                  << std::right << std::setw(10) << pi->timeCpuReal(i).first/std::max(1, totalEvents()) << " "
                                  << std::right << std::setw(10) << pi->timeCpuReal(i).second/std::max(1, totalEvents()) << " "
                                  << std::right << std::setw(10) << pi->timeCpuReal(i).first/std::max(1, pi->timesVisited(i)) << " "
                                  << std::right << std::setw(10) << pi->timeCpuReal(i).second/std::max(1, pi->timesVisited(i)) << " "
                                  << pi->getWorker(i)->description().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" << "";
    ai = workersBegin();
    ae = workersEnd();
    for (; ai != ae; ++ai) {
      LogVerbatim("FwkSummary") << "TimeReport "
                                << std::setprecision(6) << std::fixed
                                << std::right << std::setw(10) << (*ai)->timeCpuReal().first/std::max(1, totalEvents()) << " "
                                << std::right << std::setw(10) << (*ai)->timeCpuReal().second/std::max(1, totalEvents()) << " "
                                << std::right << std::setw(10) << (*ai)->timeCpuReal().first/std::max(1, (*ai)->timesRun()) << " "
                                << std::right << std::setw(10) << (*ai)->timeCpuReal().second/std::max(1, (*ai)->timesRun()) << " "
                                << std::right << std::setw(10) << (*ai)->timeCpuReal().first/std::max(1, (*ai)->timesVisited()) << " "
                                << std::right << std::setw(10) << (*ai)->timeCpuReal().second/std::max(1, (*ai)->timesVisited()) << " "
                                << (*ai)->description().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 1240 of file Schedule.cc.

References endpathsAreActive_.

                                  {
    return endpathsAreActive_;
  }

void edm::Schedule::fillEndPath ( ParameterSet &  proc_pset, ProductRegistry &  preg, boost::shared_ptr< ProcessConfiguration const >  processConfiguration, int  bitpos, std::string const &  name  )

private

Definition at line 745 of file Schedule.cc.

References act_table_, actReg_, addToAllWorkers(), end_paths_, endpath_results_, fillWorkers(), edm::for_all(), AlCaHLTBitMon_ParallelJobs::p, edm::Path::useStopwatch(), and wantSummary_.

Referenced by Schedule().

                                                                {
    PathWorkers tmpworkers;
    fillWorkers(proc_pset, preg, 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()) {
      Path p(bitpos, name, tmpworkers, endpath_results_, *act_table_, actReg_, true);
      if (wantSummary_) {
        p.useStopwatch();
      }
      end_paths_.push_back(p);
    }
    for_all(holder, boost::bind(&Schedule::addToAllWorkers, this, _1));
  }

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

private

Definition at line 720 of file Schedule.cc.

References act_table_, actReg_, addToAllWorkers(), fillWorkers(), edm::for_all(), AlCaHLTBitMon_ParallelJobs::p, trig_paths_, edm::Path::useStopwatch(), and wantSummary_.

Referenced by Schedule().

                                                             {
    PathWorkers tmpworkers;
    Workers holder;
    fillWorkers(proc_pset, preg, 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()) {
      Path p(bitpos, name, tmpworkers, trptr, *act_table_, actReg_, false);
      if (wantSummary_) {
        p.useStopwatch();
      }
      trig_paths_.push_back(p);
    }
    for_all(holder, boost::bind(&Schedule::addToAllWorkers, this, _1));
  }

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

private

Definition at line 661 of file Schedule.cc.

References act_table_, edm::errors::Configuration, edm::Worker::description(), end_path_name_list_, edm::hlt::Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ParameterSet::getUntrackedParameter(), edm::WorkerRegistry::getWorker(), edm::WorkerInPath::Ignore, edm::ModuleDescription::moduleName(), mergeVDriftHistosByStation::name, edm::WorkerInPath::Normal, edm::search_all(), edm::WorkerInPath::Veto, w(), and worker_reg_.

Referenced by fillEndPath(), and fillTrigPath().

                                                     {
    vstring modnames = proc_pset.getParameter<vstring>(name);
    vstring::iterator it(modnames.begin()), ie(modnames.end());
    PathWorkers tmpworkers;

    for (; it != ie; ++it) {

      if (labelsOnPaths) labelsOnPaths->push_back(*it);

      WorkerInPath::FilterAction filterAction = WorkerInPath::Normal;
      if ((*it)[0] == '!')       filterAction = WorkerInPath::Veto;
      else if ((*it)[0] == '-')  filterAction = WorkerInPath::Ignore;

      std::string moduleLabel = *it;
      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_, name)) {
          pathType = std::string("path");
        }
        throw Exception(errors::Configuration) <<
          "The unknown module label \"" << moduleLabel <<
          "\" appears in " << pathType << " \"" << name <<
          "\"\n please check spelling or remove that label from the path.";
      }
      assert(isTracked);

      WorkerParams params(proc_pset, modpset, preg, processConfiguration, *act_table_);
      Worker* worker = worker_reg_.getWorker(params, moduleLabel);
      if (ignoreFilters && filterAction != WorkerInPath::Ignore && dynamic_cast<WorkerT<EDFilter>*>(worker)) {
        // 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 '" << name << "'.\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";
        }
      }
      WorkerInPath w(worker, filterAction);
      tmpworkers.push_back(w);
    }

    out.swap(tmpworkers);
  }

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

References all_workers_, alignCSCRings::e, i, AlCaHLTBitMon_ParallelJobs::p, query::result, workersBegin(), and workersEnd().

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

                                           {
    AllWorkers::const_iterator i(workersBegin());
    AllWorkers::const_iterator e(workersEnd());

    std::vector<ModuleDescription const*> result;
    result.reserve(all_workers_.size());

    for (; i != e; ++i) {
      ModuleDescription const* p = (*i)->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 1292 of file Schedule.cc.

References all_workers_, end_paths_, edm::TriggerReport::endPathSummaries, edm::TriggerReport::eventSummary, edm::fillPathSummary(), edm::fillWorkerSummary(), 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(all_workers_, rep.workerSummaries,   &fillWorkerSummary);
  }

void edm::Schedule::initializeEarlyDelete ( edm::ParameterSet const &  opts, edm::ProductRegistry const &  preg, edm::ParameterSet const *  subProcPSet  )

private

Definition at line 331 of file Schedule.cc.

References all_workers_, delta, alignCSCRings::e, earlyDeleteBranchToCount_, earlyDeleteHelpers_, earlyDeleteHelperToBranchIndicies_, end_paths_, newFWLiteAna::found, edm::detail::ThreadSafeRegistry< KEY, T, E >::getMapped(), i, getHLTprescales::index, edm::InEvent, edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), edm::OutputWorker::keptProducts(), prof2calltree::l, n, AlCaHLTBitMon_ParallelJobs::p, resetEarlyDelete(), and trig_paths_.

Referenced by Schedule().

                                                                           {
    //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(subProcPSet)  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();
    for (AllWorkers::iterator i = all_workers_.begin(), e = all_workers_.end();
         i != e;
         ++i) {
      OutputWorker* ow = dynamic_cast<OutputWorker*>(*i);
      if (ow) {
        if(branchToReadingWorker.size()>0) {
          //If an OutputModule needs a product, we can't delete it early
          // so we should remove it from our list
          SelectionsArray const&kept = ow->keptProducts();
          for( auto const& item: kept[InEvent]) {
            auto found = branchToReadingWorker.equal_range(item->branchName());
            if(found.first !=found.second) {
              --nUniqueBranchesToDelete;
              branchToReadingWorker.erase(found.first,found.second);
            }
          }
        }
      } else {
        if(branchToReadingWorker.size()>0) {
          //determine if this module could read a branch we want to delete early
          auto pset = pset::Registry::instance()->getMapped((*i)->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[*i];
                if(nullptr == found.first->second) {
                  found.first->second = *i;
                } else {
                  branchToReadingWorker.insert(make_pair(found.first->first,*i));
                }
              }
            }
          }
        }
      }
    }
    {
      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(std::make_pair(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(EarlyDeleteHelper(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::Schedule::limitOutput ( ParameterSet const &  proc_pset )

private

Definition at line 599 of file Schedule.cc.

References all_output_workers_, 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, and edm::search_all().

Referenced by Schedule().

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

    if (maxEventSpecs == 0) {
      return;
    }

    for (AllOutputWorkers::const_iterator it = all_output_workers_.begin(), itEnd = all_output_workers_.end();
        it != itEnd; ++it) {
      OutputModuleDescription desc(maxEventsOut);
      if (vMaxEventsOut != 0 && !vMaxEventsOut->empty()) {
        std::string moduleLabel = (*it)->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";
        }
      }
      (*it)->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 1218 of file Schedule.cc.

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

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

                                                                     {
    TrigPaths::const_iterator itFound =
    std::find_if (trig_paths_.begin(),
                 trig_paths_.end(),
                 boost::bind(std::equal_to<std::string>(),
                             iPathLabel,
                             boost::bind(&Path::name, _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());
      }
    }
  }

void edm::Schedule::openNewOutputFilesIfNeeded

(

)

Definition at line 1122 of file Schedule.cc.

References all_output_workers_, edm::for_all(), and edm::OutputWorker::openNewFileIfNeeded().

                                            {
    for_all(all_output_workers_, boost::bind(&OutputWorker::openNewFileIfNeeded, _1));
  }

void edm::Schedule::openOutputFiles

(

FileBlock &

fb

)

Definition at line 1126 of file Schedule.cc.

References all_output_workers_, edm::for_all(), and edm::OutputWorker::openFile().

                                              {
    for_all(all_output_workers_, boost::bind(&OutputWorker::openFile, _1, boost::cref(fb)));
  }

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

Definition at line 1169 of file Schedule.cc.

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

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

void edm::Schedule::preForkReleaseResources

(

)

Definition at line 1166 of file Schedule.cc.

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

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

template<typename T >

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

Definition at line 439 of file Schedule.h.

References act_table_, alignCSCRings::action, cms::Exception::addContext(), edm::addContextAndPrintException(), edm::convertException::badAllocToEDM(), trackerHits::c, cms::Exception::category(), edm::convertException::charPtrToEDM(), cms::Exception::context(), alignCSCRings::e, endpathsAreActive_, cppFunctionSkipper::exception, edm::actions::FailPath, edm::ActionTable::find(), edm::actions::IgnoreCompletely, Latched, edm::printCmsExceptionWarning(), Ready, resetAll(), resetEarlyDelete(), results_inserter_, edm::actions::Rethrow, Running, alignCSCRings::s, setupOnDemandSystem(), edm::actions::SkipEvent, state_, edm::convertException::stdToEDM(), stopwatch_, edm::convertException::stringToEDM(), total_events_, total_passed_, edm::convertException::unknownToEDM(), and unscheduled_.

                                                                {
    this->resetAll();
    state_ = Running;

    // A RunStopwatch, but only if we are processing an event.
    RunStopwatch stopwatch(T::isEvent_ ? stopwatch_ : RunStopwatch::StopwatchPointer());

    if (T::isEvent_) {
      ++total_events_;
      setupOnDemandSystem(dynamic_cast<EventPrincipal&>(ep), es);
    }
    try {
      try {
        try {
          //make sure the unscheduled items see this transition [Event will be a no-op]
          unscheduled_->runNow<T>(ep, es);
          if (runTriggerPaths<T>(ep, es)) {
            if (T::isEvent_) ++total_passed_;
          }
          state_ = Latched;
        }
        catch(cms::Exception& e) {
          actions::ActionCodes action = (T::isEvent_ ? act_table_->find(e.category()) : actions::Rethrow);
          assert (action != actions::IgnoreCompletely);
          assert (action != actions::FailPath);
          if (action == actions::SkipEvent) {
            edm::printCmsExceptionWarning("SkipEvent", e);
          } else {
            throw;
          }
        }

        try {
          CPUTimer timer;
          if (results_inserter_.get()) results_inserter_->doWork<T>(ep, es, 0, &timer);
        }
        catch (cms::Exception & ex) {
          if (T::isEvent_) {
            ex.addContext("Calling produce method for module TriggerResultInserter");
          }
      std::ostringstream ost;
          ost << "Processing " << ep.id();
          ex.addContext(ost.str());
          throw;
        }

        if (endpathsAreActive_) runEndPaths<T>(ep, es);
        if(T::isEvent_) resetEarlyDelete();
      }
      catch (cms::Exception& e) { throw; }
      catch(std::bad_alloc& bda) { convertException::badAllocToEDM(); }
      catch (std::exception& e) { convertException::stdToEDM(e); }
      catch(std::string& s) { convertException::stringToEDM(s); }
      catch(char const* c) { convertException::charPtrToEDM(c); }
      catch (...) { convertException::unknownToEDM(); }
    }
    catch(cms::Exception& ex) {
      if (ex.context().empty()) {
        addContextAndPrintException("Calling function Schedule::processOneOccurrence", ex, cleaningUpAfterException);
      } else {
        addContextAndPrintException("", ex, cleaningUpAfterException);
      }
      state_ = Ready;
      throw;
    }
    // next thing probably is not needed, the product insertion code clears it
    state_ = Ready;
  }

void edm::Schedule::reduceParameterSet ( ParameterSet &  proc_pset, vstring &  modulesInConfig, std::set< std::string > const &  modulesInConfigSet, vstring &  labelsOnTriggerPaths, vstring &  shouldBeUsedLabels, std::map< std::string, std::vector< std::pair< std::string, int > > > &  outputModulePathPositions  )

private

Definition at line 481 of file Schedule.cc.

References edm::ParameterSet::addParameter(), alignCSCRings::e, end_path_name_list_, edm::ParameterSet::eraseOrSetUntrackedParameterSet(), edm::ParameterSet::eraseSimpleParameter(), edm::for_all(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), i, reco_calib_source_client_cfg::labels, and edm::sort_all().

Referenced by Schedule().

                                                                                                                        {

    // Before calculating the ParameterSetID of the top level ParameterSet or
    // saving it in the registry drop from the top level ParameterSet all
    // OutputModules and EDAnalyzers not on trigger paths. If unscheduled
    // production is not enabled also drop all the EDFilters and EDProducers
    // that are not scheduled. Drop the ParameterSet used to configure the module
    // itself. Also drop the other traces of these labels in the top level
    // ParameterSet: Remove that labels from @all_modules and from all the
    // end paths. If this makes any end paths empty, then remove the end path
    // name from @end_paths, and @paths.

    // First make a list of labels to drop
    vstring labelsToBeDropped;
    vstring outputModuleLabels;
    std::string edmType;
    std::string const moduleEdmType("@module_edm_type");
    std::string const outputModule("OutputModule");
    std::string const edAnalyzer("EDAnalyzer");
    std::string const edFilter("EDFilter");
    std::string const edProducer("EDProducer");
    sort_all(labelsOnTriggerPaths);
    vstring::const_iterator iLabelsOnTriggerPaths = labelsOnTriggerPaths.begin();
    vstring::const_iterator endLabelsOnTriggerPaths = labelsOnTriggerPaths.end();
    sort_all(shouldBeUsedLabels);
    vstring::const_iterator iShouldBeUsedLabels = shouldBeUsedLabels.begin();
    vstring::const_iterator endShouldBeUsedLabels = shouldBeUsedLabels.end();

    for (std::set<std::string>::const_iterator i = modulesInConfigSet.begin(),
       e = modulesInConfigSet.end(); i != e; ++i) {
      edmType = proc_pset.getParameterSet(*i).getParameter<std::string>(moduleEdmType);
      if (edmType == outputModule) {
        labelsToBeDropped.push_back(*i);
        outputModuleLabels.push_back(*i);
      }
      else if (edmType == edAnalyzer) {
        while (iLabelsOnTriggerPaths != endLabelsOnTriggerPaths &&
               *iLabelsOnTriggerPaths < *i) {
          ++iLabelsOnTriggerPaths;
        }
        if (iLabelsOnTriggerPaths == endLabelsOnTriggerPaths ||
            *iLabelsOnTriggerPaths != *i) {
          labelsToBeDropped.push_back(*i);
        }
      }
      else if (edmType == edFilter || edmType == edProducer) {
        while (iShouldBeUsedLabels != endShouldBeUsedLabels &&
               *iShouldBeUsedLabels < *i) {
          ++iShouldBeUsedLabels;
        }
        if (iShouldBeUsedLabels != endShouldBeUsedLabels &&
            *iShouldBeUsedLabels == *i) {
          labelsToBeDropped.push_back(*i);
        }
      }
    }

    // drop the parameter sets used to configure the modules
    for_all(labelsToBeDropped, boost::bind(&ParameterSet::eraseOrSetUntrackedParameterSet, boost::ref(proc_pset), _1));

    // drop the labels from @all_modules
    vstring::iterator endAfterRemove = std::remove_if(modulesInConfig.begin(), modulesInConfig.end(), boost::bind(binary_search_string, boost::ref(labelsToBeDropped), _1));
    modulesInConfig.erase(endAfterRemove, modulesInConfig.end());
    proc_pset.addParameter<vstring>(std::string("@all_modules"), modulesInConfig);

    // drop the labels from all end paths
    vstring endPathsToBeDropped;
    vstring labels;
    for (vstring::iterator iEndPath = end_path_name_list_.begin(), endEndPath = end_path_name_list_.end();
         iEndPath != endEndPath;
         ++iEndPath) {
      labels = proc_pset.getParameter<vstring>(*iEndPath);
      vstring::iterator iSave = labels.begin();
      vstring::iterator iBegin = labels.begin();

      for (vstring::iterator iLabel = labels.begin(), iEnd = labels.end();
           iLabel != iEnd; ++iLabel) {
        if (binary_search_string(labelsToBeDropped, *iLabel)) {
          if (binary_search_string(outputModuleLabels, *iLabel)) {
            outputModulePathPositions[*iLabel].push_back(std::pair<std::string, int>(*iEndPath, iSave - iBegin));
          }
        } else {
          if (iSave != iLabel) {
            iSave->swap(*iLabel);
          }
          ++iSave;
        }
      }
      labels.erase(iSave, labels.end());
      if (labels.empty()) {
        // remove empty end paths and save their names
        proc_pset.eraseSimpleParameter(*iEndPath);
        endPathsToBeDropped.push_back(*iEndPath);
      } else {
        proc_pset.addParameter<vstring>(*iEndPath, labels);
      }
    }
    sort_all(endPathsToBeDropped);
    
    // remove empty end paths from @paths
    vstring scheduledPaths = proc_pset.getParameter<vstring>("@paths");
    endAfterRemove = std::remove_if(scheduledPaths.begin(), scheduledPaths.end(), boost::bind(binary_search_string, boost::ref(endPathsToBeDropped), _1));
    scheduledPaths.erase(endAfterRemove, scheduledPaths.end());
    proc_pset.addParameter<vstring>(std::string("@paths"), scheduledPaths);

    // remove empty end paths from @end_paths
    vstring scheduledEndPaths = proc_pset.getParameter<vstring>("@end_paths");
    endAfterRemove = std::remove_if(scheduledEndPaths.begin(), scheduledEndPaths.end(), boost::bind(binary_search_string, boost::ref(endPathsToBeDropped), _1));
    scheduledEndPaths.erase(endAfterRemove, scheduledEndPaths.end());
    proc_pset.addParameter<vstring>(std::string("@end_paths"), scheduledEndPaths);
  }

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

inlineprivate

Definition at line 432 of file Schedule.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::Schedule::reportSkipped ( LuminosityBlockPrincipal const &  ) const

inlineprivate

Definition at line 256 of file Schedule.h.

{}

void edm::Schedule::reportSkipped ( RunPrincipal const &  ) const

inlineprivate

Definition at line 257 of file Schedule.h.

{}

void edm::Schedule::resetAll ( )

private

Definition at line 1311 of file Schedule.cc.

References all_workers_, endpath_results_, edm::for_all(), edm::Worker::reset(), and results_.

Referenced by processOneOccurrence().

                     {
    for_all(all_workers_, boost::bind(&Worker::reset, _1));
    results_->reset();
    endpath_results_->reset();
  }

void edm::Schedule::resetEarlyDelete ( )

private

Definition at line 1335 of file Schedule.cc.

References prof2calltree::count, earlyDeleteBranchToCount_, earlyDeleteHelpers_, earlyDeleteHelperToBranchIndicies_, and getHLTprescales::index.

Referenced by initializeEarlyDelete(), and processOneOccurrence().

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

void edm::Schedule::respondToCloseInputFile

(

FileBlock const &

fb

)

Definition at line 1149 of file Schedule.cc.

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

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

void edm::Schedule::respondToCloseOutputFiles

(

FileBlock const &

fb

)

Definition at line 1157 of file Schedule.cc.

References all_workers_, edm::for_all(), and edm::Worker::respondToCloseOutputFiles().

                                                              {
    for_all(all_workers_, boost::bind(&Worker::respondToCloseOutputFiles, _1, boost::cref(fb)));
  }

void edm::Schedule::respondToOpenInputFile

(

FileBlock const &

fb

)

Definition at line 1145 of file Schedule.cc.

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

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

void edm::Schedule::respondToOpenOutputFiles

(

FileBlock const &

fb

)

Definition at line 1153 of file Schedule.cc.

References all_workers_, edm::for_all(), and edm::Worker::respondToOpenOutputFiles().

                                                             {
    for_all(all_workers_, boost::bind(&Worker::respondToOpenOutputFiles, _1, boost::cref(fb)));
  }

template<typename T >

void edm::Schedule::runEndPaths ( typename T::MyPrincipal &  ep, EventSetup const &  es  )

private

Definition at line 519 of file Schedule.h.

References end_paths_, and edm::for_all().

                                                                       {
    // Note there is no state-checking safety controlling the
    // activation/deactivation of endpaths.
    for_all(end_paths_, ProcessOneOccurrence<T>(ep, es));

    // We could get rid of the functor ProcessOneOccurrence if we used
    // boost::lambda, but the use of lambda with member functions
    // which take multiple arguments, by both non-const and const
    // reference, seems much more obscure...
    //
    // using namespace boost::lambda;
    // for_all(end_paths_,
    //          bind(&Path::processOneOccurrence,
    //               boost::lambda::_1, // qualification to avoid ambiguity
    //               var(ep),           //  pass by reference (not copy)
    //               constant_ref(es))); // pass by const-reference (not copy)
  }

template<typename T >

bool edm::Schedule::runTriggerPaths ( typename T::MyPrincipal &  ep, EventSetup const &  es  )

private

Definition at line 512 of file Schedule.h.

References edm::for_all(), results_, and trig_paths_.

                                                                           {
    for_all(trig_paths_, ProcessOneOccurrence<T>(ep, es));
    return results_->accept();
  }

void edm::Schedule::setupOnDemandSystem ( EventPrincipal &  principal, EventSetup const &  es  )

private

Definition at line 1328 of file Schedule.cc.

References edm::EventPrincipal::setUnscheduledHandler(), and unscheduled_.

Referenced by processOneOccurrence().

                                                                        {
    // NOTE: who owns the productdescrption?  Just copied by value
    unscheduled_->setEventSetup(es);
    ep.setUnscheduledHandler(unscheduled_);
  }

bool edm::Schedule::shouldWeCloseOutput

(

)

const

Definition at line 1138 of file Schedule.cc.

References all_output_workers_, and edm::OutputWorker::shouldWeCloseFile().

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

bool edm::Schedule::terminate

(

void

)

const

Return whether each output module has reached its maximum count.

Definition at line 643 of file Schedule.cc.

References all_output_workers_.

                                 {
    if (all_output_workers_.empty()) {
      return false;
    }
    for (AllOutputWorkers::const_iterator it = all_output_workers_.begin(),
         itEnd = all_output_workers_.end();
         it != itEnd; ++it) {
      if (!(*it)->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;
  }

std::pair<double, double> edm::Schedule::timeCpuReal ( ) const

inline

Definition at line 167 of file Schedule.h.

References stopwatch_.

Referenced by endJob().

                                                {
      return std::pair<double, double>(stopwatch_->cpuTime(), stopwatch_->realTime());
    }

int edm::Schedule::totalEvents ( ) const

inline

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

References total_events_.

Referenced by endJob(), getTriggerReport(), and totalEventsFailed().

                            {
      return total_events_;
    }

int edm::Schedule::totalEventsFailed ( ) const

inline

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

Definition at line 201 of file Schedule.h.

References totalEvents(), and totalEventsPassed().

Referenced by endJob(), and getTriggerReport().

                                  {
      return totalEvents() - totalEventsPassed();
    }

int edm::Schedule::totalEventsPassed ( ) const

inline

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

Definition at line 195 of file Schedule.h.

References total_passed_.

Referenced by endJob(), getTriggerReport(), and totalEventsFailed().

                                  {
      return total_passed_;
    }

AllWorkers::const_iterator edm::Schedule::workersBegin ( ) const

inlineprivate

Definition at line 229 of file Schedule.h.

References all_workers_.

Referenced by endJob(), getAllModuleDescriptions(), and Schedule().

                                                  {
      return all_workers_.begin();
    }

AllWorkers::iterator edm::Schedule::workersBegin ( )

inlineprivate

Definition at line 237 of file Schedule.h.

References all_workers_.

                                      {
      return  all_workers_.begin();
    }

AllWorkers::const_iterator edm::Schedule::workersEnd ( ) const

inlineprivate

Definition at line 233 of file Schedule.h.

References all_workers_.

Referenced by endJob(), getAllModuleDescriptions(), and Schedule().

                                                {
      return all_workers_.end();
    }

AllWorkers::iterator edm::Schedule::workersEnd ( )

inlineprivate

Definition at line 241 of file Schedule.h.

References all_workers_.

                                    {
      return all_workers_.end();
    }

void edm::Schedule::writeLumi

(

LuminosityBlockPrincipal const &

lbp

)

Definition at line 1134 of file Schedule.cc.

References all_output_workers_, edm::for_all(), and edm::OutputWorker::writeLumi().

                                                              {
    for_all(all_output_workers_, boost::bind(&OutputWorker::writeLumi, _1, boost::cref(lbp)));
  }

void edm::Schedule::writeRun

(

RunPrincipal const &

rp

)

Definition at line 1130 of file Schedule.cc.

References all_output_workers_, edm::for_all(), and edm::OutputWorker::writeRun().

                                                {
    for_all(all_output_workers_, boost::bind(&OutputWorker::writeRun, _1, boost::cref(rp)));
  }

Member Data Documentation

ActionTable const* edm::Schedule::act_table_

private

Definition at line 291 of file Schedule.h.

Referenced by fillEndPath(), fillTrigPath(), fillWorkers(), processOneOccurrence(), and Schedule().

boost::shared_ptr<ActivityRegistry> edm::Schedule::actReg_

private

Definition at line 292 of file Schedule.h.

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

AllOutputWorkers edm::Schedule::all_output_workers_

private

Definition at line 303 of file Schedule.h.

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

AllWorkers edm::Schedule::all_workers_

private

Definition at line 302 of file Schedule.h.

Referenced by addToAllWorkers(), beginJob(), changeModule(), clearCounters(), getAllModuleDescriptions(), getTriggerReport(), initializeEarlyDelete(), postForkReacquireResources(), preForkReleaseResources(), resetAll(), respondToCloseInputFile(), respondToCloseOutputFiles(), respondToOpenInputFile(), respondToOpenOutputFiles(), Schedule(), workersBegin(), and workersEnd().

std::vector<std::pair<BranchID,unsigned int> > edm::Schedule::earlyDeleteBranchToCount_

private

Definition at line 310 of file Schedule.h.

Referenced by initializeEarlyDelete(), and resetEarlyDelete().

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

private

Definition at line 320 of file Schedule.h.

Referenced by initializeEarlyDelete(), and resetEarlyDelete().

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

private

Definition at line 317 of file Schedule.h.

Referenced by initializeEarlyDelete(), and resetEarlyDelete().

vstring edm::Schedule::end_path_name_list_

private

Definition at line 296 of file Schedule.h.

Referenced by fillWorkers(), reduceParameterSet(), and Schedule().

TrigPaths edm::Schedule::end_paths_

private

Definition at line 305 of file Schedule.h.

Referenced by clearCounters(), endJob(), fillEndPath(), getTriggerReport(), initializeEarlyDelete(), and runEndPaths().

TrigResPtr edm::Schedule::endpath_results_

private

Definition at line 299 of file Schedule.h.

Referenced by fillEndPath(), resetAll(), and Schedule().

volatile bool edm::Schedule::endpathsAreActive_

private

Definition at line 329 of file Schedule.h.

Referenced by enableEndPaths(), endPathsEnabled(), and processOneOccurrence().

TrigResPtr edm::Schedule::results_

private

Definition at line 298 of file Schedule.h.

Referenced by resetAll(), runTriggerPaths(), and Schedule().

WorkerPtr edm::Schedule::results_inserter_

private

Definition at line 301 of file Schedule.h.

Referenced by processOneOccurrence(), and Schedule().

State edm::Schedule::state_

private

Definition at line 294 of file Schedule.h.

Referenced by processOneOccurrence().

RunStopwatch::StopwatchPointer edm::Schedule::stopwatch_

private

Definition at line 325 of file Schedule.h.

Referenced by processOneOccurrence(), and timeCpuReal().

int edm::Schedule::total_events_

private

Definition at line 323 of file Schedule.h.

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

int edm::Schedule::total_passed_

private

Definition at line 324 of file Schedule.h.

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

vstring edm::Schedule::trig_name_list_

private

Definition at line 295 of file Schedule.h.

Referenced by Schedule().

TrigPaths edm::Schedule::trig_paths_

private

Definition at line 304 of file Schedule.h.

Referenced by availablePaths(), clearCounters(), endJob(), fillTrigPath(), getTriggerReport(), initializeEarlyDelete(), modulesInPath(), and runTriggerPaths().

boost::shared_ptr<UnscheduledCallProducer> edm::Schedule::unscheduled_

private

Definition at line 327 of file Schedule.h.

Referenced by processOneOccurrence(), Schedule(), and setupOnDemandSystem().

bool edm::Schedule::wantSummary_

private

Definition at line 322 of file Schedule.h.

Referenced by addToAllWorkers(), endJob(), fillEndPath(), and fillTrigPath().

WorkerRegistry edm::Schedule::worker_reg_

private

Definition at line 290 of file Schedule.h.

Referenced by fillWorkers(), and Schedule().