edm::service::ConcurrentModuleTimer Class Reference

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

Private Member Functions
void	start ()
void	stop ()

Private Attributes
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 28 of file ConcurrentModuleTimer.cc.

Constructor & Destructor Documentation

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

Definition at line 63 of file ConcurrentModuleTimer.cc.

                                                                                                     :
m_time(),
m_nModules(0),
m_spinLock{false},
m_startedTiming(false)
{
  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;
    }
    start();
  });
  iReg.watchPostSourceEvent([this](StreamID){
    stop();
  });
}

ConcurrentModuleTimer::~ConcurrentModuleTimer

(

)

Definition at line 107 of file ConcurrentModuleTimer.cc.

References gather_cfg::cout, 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::start ( void  )

private

Definition at line 137 of file ConcurrentModuleTimer.cc.

References assert(), mps_update::diff, i, m_nModules, m_spinLock, m_time, m_timeSums, and fileCollector::now.

Referenced by progressbar.ProgressBar::__next__().

{
  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 160 of file ConcurrentModuleTimer.cc.

References assert(), mps_update::diff, i, m_nModules, m_spinLock, m_time, m_timeSums, and fileCollector::now.

{
  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());
  }
}

Member Data Documentation

unsigned int edm::service::ConcurrentModuleTimer::m_nModules

private

Definition at line 40 of file ConcurrentModuleTimer.cc.

Referenced by start(), and stop().

unsigned int edm::service::ConcurrentModuleTimer::m_nTimeSums

private

Definition at line 39 of file ConcurrentModuleTimer.cc.

Referenced by ~ConcurrentModuleTimer().

std::atomic<bool> edm::service::ConcurrentModuleTimer::m_spinLock

private

Definition at line 41 of file ConcurrentModuleTimer.cc.

Referenced by start(), and stop().

bool edm::service::ConcurrentModuleTimer::m_startedTiming

private

Definition at line 42 of file ConcurrentModuleTimer.cc.

std::chrono::high_resolution_clock::time_point edm::service::ConcurrentModuleTimer::m_time

private

Definition at line 38 of file ConcurrentModuleTimer.cc.

Referenced by start(), and stop().

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

private

Definition at line 37 of file ConcurrentModuleTimer.cc.

Referenced by start(), stop(), and ~ConcurrentModuleTimer().