Public Member Functions
	ConcurrentModuleTimer (edm::ParameterSet const &iConfig, edm::ActivityRegistry &iAR)

	~ConcurrentModuleTimer ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	start ()

void	stop ()

bool	trackModule (ModuleCallingContext const &iContext) const

Private Attributes
std::vector< unsigned int >	m_excludedModuleIds

bool	m_excludeSource

std::vector< std::string >	m_modulesToExclude

unsigned int	m_nModules

unsigned int	m_nTimeSums

std::atomic< bool >	m_spinLock

bool	m_startedTiming

std::chrono::high_resolution_clock::time_point	m_time

std::unique_ptr< std::atomic< std::chrono::high_resolution_clock::rep >[]>	m_timeSums

Detailed Description

Definition at line 29 of file ConcurrentModuleTimer.cc.

Constructor & Destructor Documentation

ConcurrentModuleTimer::ConcurrentModuleTimer	(	edm::ParameterSet const &	iConfig,
		edm::ActivityRegistry &	iAR
	)

Definition at line 68 of file ConcurrentModuleTimer.cc.

References mps_fire::i, edm::ModuleDescription::id(), edm::ModuleCallingContext::kRunning, m_excludedModuleIds, m_excludeSource, m_modulesToExclude, m_nTimeSums, m_startedTiming, m_time, m_timeSums, edm::service::SystemBounds::maxNumberOfThreads(), edm::ModuleDescription::moduleLabel(), dataset::name, cmsPerfSuiteHarvest::now, start(), edm::ModuleCallingContext::state(), stop(), and trackModule().

                                                                                                      :
 m_modulesToExclude(iConfig.getUntrackedParameter<std::vector<std::string>>("modulesToExclude")),
 m_time(),
 m_nModules(0),
 m_spinLock{false},
 m_startedTiming(false),
 m_excludeSource(iConfig.getUntrackedParameter<bool>("excludeSource"))
 {
   if(not m_modulesToExclude.empty()) {
     iReg.watchPreModuleConstruction( [this](ModuleDescription const& iMod) {
       for(auto const& name: m_modulesToExclude) {
         if( iMod.moduleLabel() == name) {
           m_excludedModuleIds.push_back(iMod.id());
           break;
         }
       }
     });
     iReg.watchPreModuleEvent([this](StreamContext const&, ModuleCallingContext const& iContext){
       if(trackModule(iContext)) {
         start();
       }
     });
     iReg.watchPostModuleEvent([this](StreamContext const&, ModuleCallingContext const& iContext){
       if(trackModule(iContext)) {
         stop();
       }
     });
     
     iReg.watchPreModuleEventDelayedGet([this](StreamContext const&, ModuleCallingContext const& iContext){
       if(trackModule(iContext)) {
         if(iContext.state() == ModuleCallingContext::State::kRunning) {
           stop();
         }
       }
     });
     iReg.watchPostModuleEventDelayedGet([this](StreamContext const&, ModuleCallingContext const& iContext){
       if(trackModule(iContext)) {
         if(iContext.state() == ModuleCallingContext::State::kRunning) {
           start();
         }
       }
     });
     
   } else {
     //apply to all modules so can use faster version
     iReg.watchPreModuleEvent([this](StreamContext const&, ModuleCallingContext const&){
       start();
     });
     iReg.watchPostModuleEvent([this](StreamContext const&, ModuleCallingContext const&){
       stop();
     });
     
     iReg.watchPreModuleEventDelayedGet([this](StreamContext const&, ModuleCallingContext const& iContext){
         if(iContext.state() == ModuleCallingContext::State::kRunning) {
     stop();
         }
     });
     iReg.watchPostModuleEventDelayedGet([this](StreamContext const&, ModuleCallingContext const& iContext){
         if(iContext.state() == ModuleCallingContext::State::kRunning) {
     start();
         }
     });
   }
     
   iReg.watchPreallocate([this](edm::service::SystemBounds const& iBounds){
     m_nTimeSums =iBounds.maxNumberOfThreads()+1;
     m_timeSums.reset(new std::atomic<std::chrono::high_resolution_clock::rep>[m_nTimeSums]);
     for(unsigned int i=0; i<m_nTimeSums;++i) {
       m_timeSums[i]=0;
     }
   });
   
   iReg.watchPreSourceEvent([this](StreamID){
     if(not m_startedTiming) {
       m_time = std::chrono::high_resolution_clock::now();
       m_startedTiming=true;
     }
     if(not m_excludeSource) {
       start();
     }
   });
   if(not m_excludeSource) {
     iReg.watchPostSourceEvent([this](StreamID){
       stop();
     });
   }
 }

ConcurrentModuleTimer::~ConcurrentModuleTimer ( )

Definition at line 156 of file ConcurrentModuleTimer.cc.

References gather_cfg::cout, mps_fire::i, m_nTimeSums, and m_timeSums.

                                               {
   
   std::cout <<"Fraction of time running n Modules simultaneously"<<std::endl;
   for (unsigned int i=0; i<m_nTimeSums; ++i) {
     std::cout <<i<<" "<<m_timeSums[i]/double(m_timeSums[0])<<" "<<m_timeSums[i]<<std::endl;
   }
   
 }

Member Function Documentation

void ConcurrentModuleTimer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 250 of file ConcurrentModuleTimer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), and DEFINE_FWK_SERVICE.

 {
   edm::ParameterSetDescription desc;
   desc.addUntracked<std::vector<std::string> >("modulesToExclude", std::vector<std::string>{})->setComment("Module labels to exclude from the timing measurements");
   desc.addUntracked<bool>("excludeSource",false)->setComment("Exclude the time the source is running");
   descriptions.add("ConcurrentModuleTimer", desc);
 }

void ConcurrentModuleTimer::start ( void )

private

Definition at line 186 of file ConcurrentModuleTimer.cc.

References mps_update::diff, mps_fire::i, m_nModules, m_nTimeSums, m_spinLock, m_time, m_timeSums, and cmsPerfSuiteHarvest::now.

Referenced by progressbar.ProgressBar::__next__(), and ConcurrentModuleTimer().

 {
   auto const newTime =std::chrono::high_resolution_clock::now();
   std::chrono::high_resolution_clock::time_point oldTime;
   bool expected = false;
   unsigned int nModules;
   while (not m_spinLock.compare_exchange_strong(expected,true,std::memory_order_acq_rel)){
     expected = false;
   }
   {
     oldTime = m_time;
     m_time = newTime;
     nModules = ++m_nModules;
     m_spinLock.store(false,std::memory_order_release);
   }
   assert(nModules <m_nTimeSums);
   auto diff = newTime - oldTime;
   for(unsigned int i=0;i<nModules;++i) {
     m_timeSums[i].fetch_add(diff.count());
   }
 }

void ConcurrentModuleTimer::stop ( )

private

Definition at line 209 of file ConcurrentModuleTimer.cc.

References mps_update::diff, mps_fire::i, m_nModules, m_nTimeSums, m_spinLock, m_time, m_timeSums, and cmsPerfSuiteHarvest::now.

Referenced by ConcurrentModuleTimer().

 {
   auto const newTime =std::chrono::high_resolution_clock::now();
   std::chrono::high_resolution_clock::time_point oldTime;
   bool expected = false;
   unsigned int nModules;
   while (not m_spinLock.compare_exchange_weak(expected,true,std::memory_order_acq_rel)){
     expected = false;
   }
   {
     oldTime = m_time;
     m_time = newTime;
     nModules = m_nModules--;
     m_spinLock.store(false,std::memory_order_release);
   }
   assert(nModules <m_nTimeSums);
   auto diff = newTime - oldTime;
   for(unsigned int i=0;i<=nModules;++i) {
     m_timeSums[i].fetch_add(diff.count());
   }
 }

bool ConcurrentModuleTimer::trackModule ( ModuleCallingContext const & iContext ) const

private

Definition at line 235 of file ConcurrentModuleTimer.cc.

References edm::ModuleDescription::id(), m_excludedModuleIds, and edm::ModuleCallingContext::moduleDescription().

Referenced by ConcurrentModuleTimer().

 {
   auto modId = iContext.moduleDescription()->id();
   for(auto const id: m_excludedModuleIds) {
     if(modId == id) {
       return false;
     }
   }
   return true;
 }