#include <Path.h>

Public Types
typedef WorkersInPath::size_type	size_type

typedef hlt::HLTState	State

typedef boost::shared_ptr < HLTGlobalStatus >	TrigResPtr

typedef std::vector< WorkerInPath >	WorkersInPath

Public Member Functions
int	bitPosition () const

void	clearCounters ()

Worker const *	getWorker (size_type i) const

std::string const &	name () const

	Path (int bitpos, std::string const &path_name, WorkersInPath const &workers, TrigResPtr trptr, ActionTable const &actions, boost::shared_ptr< ActivityRegistry > reg, bool isEndPath)

template<typename T >
void	processOneOccurrence (typename T::MyPrincipal &, EventSetup const &)

void	setEarlyDeleteHelpers (std::map< const Worker , EarlyDeleteHelper > const &)

size_type	size () const

State	state () const

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

std::pair< double, double >	timeCpuReal (unsigned int const i) const

int	timesExcept () const

int	timesExcept (size_type i) const

int	timesFailed () const

int	timesFailed (size_type i) const

int	timesPassed () const

int	timesPassed (size_type i) const

int	timesRun () const

int	timesVisited (size_type i) const

void	useStopwatch ()

Private Member Functions
void	handleEarlyFinish (EventPrincipal &)

void	handleEarlyFinish (RunPrincipal &)

void	handleEarlyFinish (LuminosityBlockPrincipal &)

bool	handleWorkerFailure (cms::Exception &e, int nwrwue, bool isEvent, bool begin, BranchType branchType, CurrentProcessingContext const &cpc, std::string const &id)

void	recordStatus (int nwrwue, bool isEvent)

void	updateCounters (bool succeed, bool isEvent)

Static Private Member Functions
static void	exceptionContext (cms::Exception &ex, bool isEvent, bool begin, BranchType branchType, CurrentProcessingContext const &cpc, std::string const &id)

Private Attributes
ActionTable const *	act_table_

boost::shared_ptr < ActivityRegistry >	actReg_

int	bitpos_

std::vector< EarlyDeleteHelper * >	earlyDeleteHelpers_

bool	isEndPath_

std::string	name_

State	state_

RunStopwatch::StopwatchPointer	stopwatch_

int	timesExcept_

int	timesFailed_

int	timesPassed_

int	timesRun_

TrigResPtr	trptr_

WorkersInPath	workers_

Detailed Description

Definition at line 39 of file Path.h.

Member Typedef Documentation

typedef WorkersInPath::size_type edm::Path::size_type

Definition at line 44 of file Path.h.

typedef hlt::HLTState edm::Path::State

Definition at line 41 of file Path.h.

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

Definition at line 45 of file Path.h.

typedef std::vector<WorkerInPath> edm::Path::WorkersInPath

Definition at line 43 of file Path.h.

Constructor & Destructor Documentation

edm::Path::Path	(	int	bitpos,
		std::string const &	path_name,
		WorkersInPath const &	workers,
		TrigResPtr	trptr,
		ActionTable const &	actions,
		boost::shared_ptr< ActivityRegistry >	reg,
		bool	isEndPath
	)

Definition at line 13 of file Path.cc.

                         :
     stopwatch_(),
     timesRun_(),
     timesPassed_(),
     timesFailed_(),
     timesExcept_(),
     state_(hlt::Ready),
     bitpos_(bitpos),
     name_(path_name),
     trptr_(trptr),
     actReg_(areg),
     act_table_(&actions),
     workers_(workers),
     isEndPath_(isEndPath) {
   }

Member Function Documentation

int edm::Path::bitPosition ( ) const

inline

Definition at line 57 of file Path.h.

References bitpos_.

Referenced by edm::fillPathSummary(), and processOneOccurrence().

57 { return bitpos_; }

edm::Path::bitpos_

int bitpos_

Definition: Path.h:99

void edm::Path::clearCounters ( )

Definition at line 143 of file Path.cc.

References edm::WorkerInPath::clearCounters(), edm::for_all(), timesExcept_, timesFailed_, timesPassed_, timesRun_, and workers_.

Referenced by edm::Schedule::clearCounters().

                       {
     timesRun_ = timesPassed_ = timesFailed_ = timesExcept_ = 0;
     for_all(workers_, boost::bind(&WorkerInPath::clearCounters, _1));
   }

void edm::Path::exceptionContext	(	cms::Exception &	ex,
		bool	isEvent,
		bool	begin,
		BranchType	branchType,
		CurrentProcessingContext const &	cpc,
		std::string const &	id
	)

staticprivate

Definition at line 79 of file Path.cc.

References cms::Exception::addContext(), errorMatrix2Lands_multiChannel::id, edm::InLumi, edm::InRun, edm::CurrentProcessingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), and edm::CurrentProcessingContext::pathName().

Referenced by handleWorkerFailure().

                                               {
     std::ostringstream ost;
     if (isEvent) {
       ost << "Calling event method";
     }
     else if (begin && branchType == InRun) {
       ost << "Calling beginRun";
     }
     else if (begin && branchType == InLumi) {
       ost << "Calling beginLuminosityBlock";
     }
     else if (!begin && branchType == InLumi) {
       ost << "Calling endLuminosityBlock";
     }
     else if (!begin && branchType == InRun) {
       ost << "Calling endRun";
     }
     else {
       // It should be impossible to get here ...
       ost << "Calling unknown function";
     }
     if (cpc.moduleDescription()) {
       ost << " for module " << cpc.moduleDescription()->moduleName() << "/'" << cpc.moduleDescription()->moduleLabel() << "'";
     }
     ex.addContext(ost.str());
     ost.str("");
     ost << "Running path '";
     if (cpc.pathName()) {
       ost << *cpc.pathName() << "'";
     }
     else {
       ost << "unknown'";
     }
     ex.addContext(ost.str());
     ost.str("");
     ost << "Processing ";
     ost << id;
     ex.addContext(ost.str());
   }

Worker const* edm::Path::getWorker ( size_type i ) const

inline

Definition at line 85 of file Path.h.

References workers_.

Referenced by edm::fillModuleInPathSummary(), and setEarlyDeleteHelpers().

85 { return workers_.at(i).getWorker(); }

i

int i

Definition: DBlmapReader.cc:9

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:105

void edm::Path::handleEarlyFinish ( EventPrincipal & iEvent )

private

Definition at line 176 of file Path.cc.

References earlyDeleteHelpers_.

Referenced by processOneOccurrence().

                                                 {
     for(auto helper: earlyDeleteHelpers_) {
       helper->pathFinished(iEvent);
     }
   }

void edm::Path::handleEarlyFinish ( RunPrincipal & )

inlineprivate

Definition at line 129 of file Path.h.

129 {}

void edm::Path::handleEarlyFinish ( LuminosityBlockPrincipal & )

inlineprivate

Definition at line 130 of file Path.h.

130 {}

bool edm::Path::handleWorkerFailure	(	cms::Exception &	e,
		int	nwrwue,
		bool	isEvent,
		bool	begin,
		BranchType	branchType,
		CurrentProcessingContext const &	cpc,
		std::string const &	id
	)

private

Definition at line 35 of file Path.cc.

References act_table_, alignCSCRings::action, cms::Exception::addAdditionalInfo(), cms::Exception::category(), edm::Exception::codeToString(), edm::hlt::Exception, exceptionContext(), edm::actions::FailPath, edm::ActionTable::find(), edm::printCmsExceptionWarning(), edm::errors::ProductNotFound, recordStatus(), edm::actions::Rethrow, state_, and timesExcept_.

Referenced by processOneOccurrence().

                                                  {
 
     exceptionContext(e, isEvent, begin, branchType, cpc, id);
 
     bool should_continue = true;
 
     // there is no support as of yet for specific paths having
     // different exception behavior
     
     // If not processing an event, always rethrow.
     actions::ActionCodes action = (isEvent ? act_table_->find(e.category()) : actions::Rethrow);
     switch(action) {
       case actions::FailPath: {
       should_continue = false;
           edm::printCmsExceptionWarning("FailPath", e);
       break;
       }
       default: {
       if (isEvent) ++timesExcept_;
       state_ = hlt::Exception;
       recordStatus(nwrwue, isEvent);
       if (action == actions::Rethrow) {
         std::string pNF = Exception::codeToString(errors::ProductNotFound);
             if (e.category() == pNF) {
           std::ostringstream ost;
               ost <<  "If you wish to continue processing events after a " << pNF << " exception,\n" <<
           "add \"SkipEvent = cms.untracked.vstring('ProductNotFound')\" to the \"options\" PSet in the configuration.\n";
               e.addAdditionalInfo(ost.str());
             }
       }
           throw;
       }
     }
 
     return should_continue;
   }

std::string const& edm::Path::name ( void ) const

inline

Definition at line 58 of file Path.h.

References name_.

Referenced by edm::Schedule::availablePaths(), edm::fillPathSummary(), edm::Schedule::modulesInPath(), and Vispa.Views.PropertyView.Property::valueChanged().

58 { return name_; }

edm::Path::name_

std::string name_

Definition: Path.h:100

template<typename T >

void edm::Path::processOneOccurrence	(	typename T::MyPrincipal &	ep,
		EventSetup const &	es
	)

Definition at line 157 of file Path.h.

References edm::CurrentProcessingContext::activate(), actReg_, edm::convertException::badAllocToEDM(), bitPosition(), trackerHits::c, edm::convertException::charPtrToEDM(), alignCSCRings::e, end, cppFunctionSkipper::exception, handleEarlyFinish(), handleWorkerFailure(), i, isEndPath_, name_, edm::hlt::Ready, recordStatus(), alignCSCRings::s, state_, edm::convertException::stdToEDM(), stopwatch_, edm::convertException::stringToEDM(), timesRun_, edm::convertException::unknownToEDM(), updateCounters(), and workers_.

Referenced by edm::ProcessOneOccurrence< T >::operator()().

                                                                                  {
 
     //Create the PathSignalSentry before the RunStopwatch so that
     // we only record the time spent in the path not from the signal
     int nwrwue = -1;
     PathSignalSentry<T> signaler(actReg_.get(), name_, nwrwue, state_);
 
     // A RunStopwatch, but only if we are processing an event.
     RunStopwatch stopwatch(T::isEvent_ ? stopwatch_ : RunStopwatch::StopwatchPointer());
 
     if (T::isEvent_) {
       ++timesRun_;
     }
     state_ = hlt::Ready;
 
     // nwrue =  numWorkersRunWithoutUnhandledException
     bool should_continue = true;
     CurrentProcessingContext cpc(&name_, bitPosition(), isEndPath_);
 
     WorkersInPath::size_type idx = 0;
     // It seems likely that 'nwrwue' and 'idx' can never differ ---
     // if so, we should remove one of them!.
     for (WorkersInPath::iterator i = workers_.begin(), end = workers_.end();
           i != end && should_continue;
           ++i, ++idx) {
       ++nwrwue;
       assert (static_cast<int>(idx) == nwrwue);
       try {
         try {
           cpc.activate(idx, i->getWorker()->descPtr());
           should_continue = i->runWorker<T>(ep, es, &cpc);
         }
         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) {
         // handleWorkerFailure may throw a new exception.
     std::ostringstream ost;
         ost << ep.id();
         should_continue = handleWorkerFailure(ex, nwrwue, T::isEvent_, T::begin_, T::branchType_, cpc, ost.str());
       }
     }
     if (not should_continue) {
       handleEarlyFinish(ep);
     }
     updateCounters(should_continue, T::isEvent_);
     recordStatus(nwrwue, T::isEvent_);
   }

void edm::Path::recordStatus	(	int	nwrwue,
		bool	isEvent
	)

private

Definition at line 125 of file Path.cc.

References bitpos_, and state_.

Referenced by handleWorkerFailure(), and processOneOccurrence().

                                              {
     if(isEvent) {
       (*trptr_)[bitpos_]=HLTPathStatus(state_, nwrwue);    
     }
   }

void edm::Path::setEarlyDeleteHelpers ( std::map< const Worker *, EarlyDeleteHelper * > const & iWorkerToDeleter )

Definition at line 159 of file Path.cc.

References earlyDeleteHelpers_, newFWLiteAna::found, getWorker(), getHLTprescales::index, size(), and groupFilesInBlocks::temp.

                                                                                               {
     //we use a temp so we can overset the size but then when moving to earlyDeleteHelpers we only
     // have to use the space necessary
     std::vector<EarlyDeleteHelper*> temp;
     temp.reserve(iWorkerToDeleter.size());
     for(unsigned int index=0; index !=size();++index) {
       auto found = iWorkerToDeleter.find(getWorker(index));
       if(found != iWorkerToDeleter.end()) {
         temp.push_back(found->second);
         found->second->addedToPath();
       }
     }
     std::vector<EarlyDeleteHelper*> tempCorrectSize(temp.begin(),temp.end());
     earlyDeleteHelpers_.swap(tempCorrectSize);
   }

size_type edm::Path::size ( void ) const

inline

Definition at line 80 of file Path.h.

References workers_.

Referenced by edm::fillPathSummary(), and setEarlyDeleteHelpers().

80 { return workers_.size(); }

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:105

State edm::Path::state ( ) const

inline

Definition at line 78 of file Path.h.

References state_.

78 { return state_; }

edm::Path::state_

State state_

Definition: Path.h:97

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

inline

Definition at line 60 of file Path.h.

References stopwatch_.

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

std::pair<double, double> edm::Path::timeCpuReal ( unsigned int const i ) const

inline

Definition at line 67 of file Path.h.

References workers_.

                                                                     {
       return workers_.at(i).timeCpuReal();
     }

int edm::Path::timesExcept ( ) const

inline

Definition at line 76 of file Path.h.

References timesExcept_.

Referenced by edm::fillModuleInPathSummary(), and edm::fillPathSummary().

76 { return timesExcept_; }

edm::Path::timesExcept_

int timesExcept_

Definition: Path.h:95

int edm::Path::timesExcept ( size_type i ) const

inline

Definition at line 84 of file Path.h.

References workers_.

84 { return workers_.at(i).timesExcept() ; }

i

int i

Definition: DBlmapReader.cc:9

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:105

int edm::Path::timesFailed ( ) const

inline

Definition at line 75 of file Path.h.

References timesFailed_.

Referenced by edm::fillModuleInPathSummary(), and edm::fillPathSummary().

75 { return timesFailed_; }

edm::Path::timesFailed_

int timesFailed_

Definition: Path.h:94

int edm::Path::timesFailed ( size_type i ) const

inline

Definition at line 83 of file Path.h.

References workers_.

83 { return workers_.at(i).timesFailed() ; }

i

int i

Definition: DBlmapReader.cc:9

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:105

int edm::Path::timesPassed ( ) const

inline

Definition at line 74 of file Path.h.

References timesPassed_.

Referenced by edm::fillModuleInPathSummary(), and edm::fillPathSummary().

74 { return timesPassed_; }

edm::Path::timesPassed_

int timesPassed_

Definition: Path.h:93

int edm::Path::timesPassed ( size_type i ) const

inline

Definition at line 82 of file Path.h.

References workers_.

82 { return workers_.at(i).timesPassed() ; }

i

int i

Definition: DBlmapReader.cc:9

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:105

int edm::Path::timesRun ( ) const

inline

Definition at line 73 of file Path.h.

References timesRun_.

Referenced by edm::fillPathSummary().

73 { return timesRun_; }

edm::Path::timesRun_

int timesRun_

Definition: Path.h:92

int edm::Path::timesVisited ( size_type i ) const

inline

Definition at line 81 of file Path.h.

References workers_.

Referenced by edm::fillModuleInPathSummary().

81 { return workers_.at(i).timesVisited(); }

i

int i

Definition: DBlmapReader.cc:9

edm::Path::workers_

WorkersInPath workers_

Definition: Path.h:105

void edm::Path::updateCounters	(	bool	succeed,
		bool	isEvent
	)

private

Definition at line 132 of file Path.cc.

References edm::hlt::Fail, edm::hlt::Pass, state_, timesFailed_, and timesPassed_.

Referenced by processOneOccurrence().

                                                  {
     if (success) {
       if (isEvent) ++timesPassed_;
       state_ = hlt::Pass;
     } else {
       if(isEvent) ++timesFailed_;
       state_ = hlt::Fail;
     }
   }

void edm::Path::useStopwatch ( )

Definition at line 149 of file Path.cc.

References stopwatch_, and workers_.

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

                      {
     stopwatch_.reset(new RunStopwatch::StopwatchPointer::element_type);
     for(WorkersInPath::iterator it=workers_.begin(), itEnd = workers_.end();
         it != itEnd;
         ++it) {
       it->useStopwatch();
     }
   }