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 = 0

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 28 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 149 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 234 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 ( )

private

Definition at line 176 of file ConcurrentModuleTimer.cc.

References diffTreeTool::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 197 of file ConcurrentModuleTimer.cc.

References diffTreeTool::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 221 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;
 }