#include <SystemTimeKeeper.h>

Classes
struct	ModuleInPathTiming

struct	ModuleTiming

struct	PathTiming

Public Member Functions
void	fillTriggerTimingReport (TriggerTimingReport &rep) const

void	pauseModuleEvent (StreamContext const &, ModuleCallingContext const &)

void	restartModuleEvent (StreamContext const &, ModuleCallingContext const &)

void	startEvent (StreamID)

void	startModuleEvent (StreamContext const &, ModuleCallingContext const &)

void	startPath (StreamContext const &, PathContext const &)

void	startProcessingLoop ()

void	stopEvent (StreamContext const &)

void	stopModuleEvent (StreamContext const &, ModuleCallingContext const &)

void	stopPath (StreamContext const &, PathContext const &, HLTPathStatus const &)

void	stopProcessingLoop ()

	SystemTimeKeeper (unsigned int iNumStreams, std::vector< const ModuleDescription * > const &iModules, service::TriggerNamesService const &iNameService, ProcessContext const *iProcessContext)

Private Member Functions
bool	checkBounds (unsigned int id) const

const SystemTimeKeeper &	operator= (const SystemTimeKeeper &)=delete

PathTiming &	pathTiming (StreamContext const &, PathContext const &)

	SystemTimeKeeper (const SystemTimeKeeper &)=delete

Private Attributes
unsigned int	m_endPathOffset

unsigned int	m_minModuleID

std::vector< const ModuleDescription * >	m_modules

std::vector< std::vector< std::string > >	m_modulesOnPaths

std::atomic< unsigned int >	m_numberOfEvents

std::vector< std::string >	m_pathNames

ProcessContext const *	m_processContext

CPUTimer	m_processingLoopTimer

std::vector< WallclockTimer >	m_streamEventTimer

std::vector< std::vector< ModuleTiming > >	m_streamModuleTiming

std::vector< std::vector< PathTiming > >	m_streamPathTiming

Detailed Description

Definition at line 46 of file SystemTimeKeeper.h.

Constructor & Destructor Documentation

SystemTimeKeeper::SystemTimeKeeper	(	unsigned int	iNumStreams,
		std::vector< const ModuleDescription * > const &	iModules,
		service::TriggerNamesService const &	iNameService,
		ProcessContext const *	iProcessContext
	)

Definition at line 41 of file SystemTimeKeeper.cc.

References popcon2dropbox::copy(), edm::service::TriggerNamesService::getEndPathModules(), edm::service::TriggerNamesService::getEndPaths(), edm::service::TriggerNamesService::getTrigPathModules(), edm::service::TriggerNamesService::getTrigPaths(), mps_fire::i, edm::ModuleDescription::id(), m_endPathOffset, m_minModuleID, m_modules, m_modulesOnPaths, m_pathNames, m_streamModuleTiming, and m_streamPathTiming.

     : m_streamEventTimer(iNumStreams),
       m_streamPathTiming(iNumStreams),
       m_modules(iModules),
       m_processContext(iProcessContext),
       m_minModuleID(0),
       m_numberOfEvents(0) {
   std::sort(
       m_modules.begin(), m_modules.end(), [](const ModuleDescription* iLHS, const ModuleDescription* iRHS) -> bool {
         return iLHS->id() < iRHS->id();
       });
   if (not m_modules.empty()) {
     m_minModuleID = m_modules.front()->id();
     unsigned int numModuleSlots = m_modules.back()->id() - m_minModuleID + 1;
     m_streamModuleTiming.resize(iNumStreams);
     for (auto& stream : m_streamModuleTiming) {
       stream.resize(numModuleSlots);
     }
   }
 
   std::vector<unsigned int> numModulesInPath;
   std::vector<unsigned int> numModulesInEndPath;
 
   const unsigned int numPaths = iNamesService.getTrigPaths().size();
   const unsigned int numEndPaths = iNamesService.getEndPaths().size();
   m_pathNames.reserve(numPaths + numEndPaths);
   std::copy(iNamesService.getTrigPaths().begin(), iNamesService.getTrigPaths().end(), std::back_inserter(m_pathNames));
   std::copy(iNamesService.getEndPaths().begin(), iNamesService.getEndPaths().end(), std::back_inserter(m_pathNames));
 
   numModulesInPath.reserve(numPaths);
   numModulesInEndPath.reserve(numEndPaths);
 
   m_modulesOnPaths.reserve(numPaths + numEndPaths);
 
   for (unsigned int i = 0; i < numPaths; ++i) {
     numModulesInPath.push_back(iNamesService.getTrigPathModules(i).size());
     m_modulesOnPaths.push_back(iNamesService.getTrigPathModules(i));
   }
   for (unsigned int i = 0; i < numEndPaths; ++i) {
     numModulesInEndPath.push_back(iNamesService.getEndPathModules(i).size());
     m_modulesOnPaths.push_back(iNamesService.getEndPathModules(i));
   }
 
   m_endPathOffset = numModulesInPath.size();
 
   for (auto& stream : m_streamPathTiming) {
     unsigned int index = 0;
     stream.resize(numModulesInPath.size() + numModulesInEndPath.size());
     for (unsigned int numMods : numModulesInPath) {
       stream[index].m_moduleTiming.resize(numMods);
       ++index;
     }
     for (unsigned int numMods : numModulesInEndPath) {
       stream[index].m_moduleTiming.resize(numMods);
       ++index;
     }
   }
 }

edm::SystemTimeKeeper::SystemTimeKeeper ( const SystemTimeKeeper & )

privatedelete

Member Function Documentation

bool SystemTimeKeeper::checkBounds ( unsigned int id ) const

inlineprivate

Definition at line 120 of file SystemTimeKeeper.cc.

References m_minModuleID, and m_streamModuleTiming.

Referenced by pauseModuleEvent(), restartModuleEvent(), startModuleEvent(), and stopModuleEvent().

                                                                {
   return id >= m_minModuleID and id < m_streamModuleTiming.front().size() + m_minModuleID;
 }

void SystemTimeKeeper::fillTriggerTimingReport ( TriggerTimingReport & rep ) const

Definition at line 231 of file SystemTimeKeeper.cc.

References edm::EventTimingSummary::cpuTime, edm::CPUTimer::cpuTime(), edm::TriggerTimingReport::endPathSummaries, edm::TriggerTimingReport::eventSummary, edm::fillPathSummary(), m_endPathOffset, m_minModuleID, m_modules, m_modulesOnPaths, m_numberOfEvents, m_pathNames, m_processingLoopTimer, m_streamEventTimer, m_streamModuleTiming, m_streamPathTiming, mod(), callgraph::path, edm::EventTimingSummary::realTime, edm::CPUTimer::realTime(), findQualityFiles::size, edm::sort_all(), heppy_report::summary, edm::EventTimingSummary::sumStreamRealTime, edm::EventTimingSummary::totalEvents, edm::TriggerTimingReport::trigPathSummaries, class-composition::visited, and edm::TriggerTimingReport::workerSummaries.

                                                                              {
   {
     rep.eventSummary.totalEvents = m_numberOfEvents;
     double sumEventTime = 0.;
     for (auto const& stream : m_streamEventTimer) {
       sumEventTime += stream.realTime();
     }
     rep.eventSummary.realTime = m_processingLoopTimer.realTime();
     rep.eventSummary.cpuTime = m_processingLoopTimer.cpuTime();
     rep.eventSummary.sumStreamRealTime = sumEventTime;
   }
 
   //Per module summary
   {
     auto& summary = rep.workerSummaries;
     summary.resize(m_modules.size());
     //Figure out how often a module was visited
     std::map<std::string, unsigned int> visited;
     for (auto const& stream : m_streamPathTiming) {
       unsigned int pathIndex = 0;
       for (auto const& path : stream) {
         unsigned int modIndex = 0;
         for (auto const& mod : path.m_moduleTiming) {
           visited[m_modulesOnPaths[pathIndex][modIndex]] += mod.m_timesVisited;
           ++modIndex;
         }
         ++pathIndex;
       }
     }
 
     unsigned int modIndex = 0;
     for (auto const& mod : m_modules) {
       auto& outMod = summary[modIndex];
       outMod.moduleLabel = mod->moduleLabel();
       outMod.realTime = 0.;
 
       auto moduleId = mod->id() - m_minModuleID;
       for (auto const& stream : m_streamModuleTiming) {
         auto const& timing = stream[moduleId];
         outMod.realTime += timing.m_timer.realTime();
         outMod.timesRun += timing.m_timesRun;
       }
       outMod.timesVisited = visited[mod->moduleLabel()];
       if (0 == outMod.timesVisited) {
         outMod.timesVisited = outMod.timesRun;
       }
       ++modIndex;
     }
   }
   sort_all(rep.workerSummaries);
 
   //Per path summary
   {
     fillPathSummary(0, m_endPathOffset, m_pathNames, m_modulesOnPaths, m_streamPathTiming, rep.trigPathSummaries);
     fillPathSummary(m_endPathOffset,
                     m_streamPathTiming[0].size(),
                     m_pathNames,
                     m_modulesOnPaths,
                     m_streamPathTiming,
                     rep.endPathSummaries);
   }
 }

const SystemTimeKeeper& edm::SystemTimeKeeper::operator= ( const SystemTimeKeeper & )

privatedelete

SystemTimeKeeper::PathTiming & SystemTimeKeeper::pathTiming	(	StreamContext const &	iStream,
		PathContext const &	iPath
	)

private

Definition at line 106 of file SystemTimeKeeper.cc.

References edm::PathContext::isEndPath(), m_endPathOffset, m_streamPathTiming, PFRecoTauDiscriminationByIsolation_cfi::offset, edm::PathContext::pathID(), edm::StreamContext::streamID(), and edm::StreamID::value().

Referenced by fillPathSummary(), pauseModuleEvent(), startPath(), stopModuleEvent(), and stopPath().

                                                                                                                {
   unsigned int offset = 0;
   if (iPath.isEndPath()) {
     offset = m_endPathOffset;
   }
   assert(iPath.pathID() + offset < m_streamPathTiming[iStream.streamID().value()].size());
   return m_streamPathTiming[iStream.streamID().value()][iPath.pathID() + offset];
 }

void SystemTimeKeeper::pauseModuleEvent	(	StreamContext const &	iStream,
		ModuleCallingContext const &	iModule
	)

Definition at line 173 of file SystemTimeKeeper.cc.

References checkBounds(), edm::ModuleDescription::id(), edm::ParentContext::kPlaceInPath, m_minModuleID, edm::SystemTimeKeeper::PathTiming::m_moduleTiming, m_streamModuleTiming, mod(), edm::ModuleCallingContext::moduleDescription(), pathTiming(), edm::ModuleCallingContext::placeInPathContext(), edm::StreamContext::streamID(), create_public_lumi_plots::times, edm::ModuleCallingContext::type(), and edm::StreamID::value().

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

                                                                                                          {
   if (checkBounds(iModule.moduleDescription()->id())) {
     auto& mod = m_streamModuleTiming[iStream.streamID().value()][iModule.moduleDescription()->id() - m_minModuleID];
     auto times = mod.m_timer.stop();
 
     if (iModule.type() == ParentContext::Type::kPlaceInPath) {
       auto place = iModule.placeInPathContext();
 
       auto& modTiming = pathTiming(iStream, *(place->pathContext())).m_moduleTiming[place->placeInPath()];
       modTiming.m_realTime += times;
     }
   }
 }

void SystemTimeKeeper::restartModuleEvent	(	StreamContext const &	iStream,
		ModuleCallingContext const &	iModule
	)

Definition at line 186 of file SystemTimeKeeper.cc.

References checkBounds(), edm::ModuleDescription::id(), m_minModuleID, m_streamModuleTiming, mod(), edm::ModuleCallingContext::moduleDescription(), edm::StreamContext::streamID(), and edm::StreamID::value().

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

                                                                                                            {
   if (checkBounds(iModule.moduleDescription()->id())) {
     auto& mod = m_streamModuleTiming[iStream.streamID().value()][iModule.moduleDescription()->id() - m_minModuleID];
     mod.m_timer.start();
   }
 }

void SystemTimeKeeper::startEvent ( StreamID iID )

Definition at line 124 of file SystemTimeKeeper.cc.

References m_numberOfEvents, m_streamEventTimer, and edm::StreamID::value().

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

                                               {
   m_numberOfEvents++;
   m_streamEventTimer[iID.value()].start();
 }

void SystemTimeKeeper::startModuleEvent	(	StreamContext const &	iStream,
		ModuleCallingContext const &	iModule
	)

Definition at line 153 of file SystemTimeKeeper.cc.

References checkBounds(), edm::ModuleDescription::id(), m_minModuleID, m_streamModuleTiming, mod(), edm::ModuleCallingContext::moduleDescription(), edm::StreamContext::streamID(), and edm::StreamID::value().

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

                                                                                                          {
   if (checkBounds(iModule.moduleDescription()->id())) {
     auto& mod = m_streamModuleTiming[iStream.streamID().value()][iModule.moduleDescription()->id() - m_minModuleID];
     mod.m_timer.start();
     ++(mod.m_timesRun);
   }
 }

void SystemTimeKeeper::startPath	(	StreamContext const &	iStream,
		PathContext const &	iPath
	)

Definition at line 133 of file SystemTimeKeeper.cc.

References m_processContext, pathTiming(), and edm::StreamContext::processContext().

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

                                                                                        {
   if (m_processContext == iStream.processContext()) {
     auto& timing = pathTiming(iStream, iPath);
     timing.m_timer.start();
   }
 }

void SystemTimeKeeper::startProcessingLoop ( )

Definition at line 193 of file SystemTimeKeeper.cc.

References m_processingLoopTimer, and edm::CPUTimer::start().

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

193 { m_processingLoopTimer.start(); }

edm::CPUTimer::start

void start()

Definition: CPUTimer.cc:68

edm::SystemTimeKeeper::m_processingLoopTimer

CPUTimer m_processingLoopTimer

Definition: SystemTimeKeeper.h:107

void SystemTimeKeeper::stopEvent ( StreamContext const & iContext )

Definition at line 129 of file SystemTimeKeeper.cc.

References m_streamEventTimer, edm::StreamContext::streamID(), and edm::StreamID::value().

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

                                                               {
   m_streamEventTimer[iContext.streamID().value()].stop();
 }

void SystemTimeKeeper::stopModuleEvent	(	StreamContext const &	iStream,
		ModuleCallingContext const &	iModule
	)

Definition at line 160 of file SystemTimeKeeper.cc.

References checkBounds(), edm::ModuleDescription::id(), edm::ParentContext::kPlaceInPath, m_minModuleID, edm::SystemTimeKeeper::PathTiming::m_moduleTiming, m_streamModuleTiming, mod(), edm::ModuleCallingContext::moduleDescription(), pathTiming(), edm::ModuleCallingContext::placeInPathContext(), edm::StreamContext::streamID(), create_public_lumi_plots::times, edm::ModuleCallingContext::type(), and edm::StreamID::value().

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

                                                                                                         {
   if (checkBounds(iModule.moduleDescription()->id())) {
     auto& mod = m_streamModuleTiming[iStream.streamID().value()][iModule.moduleDescription()->id() - m_minModuleID];
     auto times = mod.m_timer.stop();
 
     if (iModule.type() == ParentContext::Type::kPlaceInPath) {
       auto place = iModule.placeInPathContext();
 
       auto& modTiming = pathTiming(iStream, *(place->pathContext())).m_moduleTiming[place->placeInPath()];
       modTiming.m_realTime += times;
     }
   }
 }

void SystemTimeKeeper::stopPath	(	StreamContext const &	iStream,
		PathContext const &	iPath,
		HLTPathStatus const &	iStatus
	)

Definition at line 140 of file SystemTimeKeeper.cc.

References mps_fire::i, edm::HLTPathStatus::index(), m_processContext, pathTiming(), and edm::StreamContext::processContext().

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

                                                                                                                     {
   if (m_processContext == iStream.processContext()) {
     auto& timing = pathTiming(iStream, iPath);
     timing.m_timer.stop();
 
     //mark all modules up to and including the decision module as being visited
     auto& modsOnPath = timing.m_moduleTiming;
     for (unsigned int i = 0; i < iStatus.index() + 1; ++i) {
       ++modsOnPath[i].m_timesVisited;
     }
   }
 }