edm::service::ConcurrentModuleTimer Class Reference

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
const bool	m_excludeSource
unsigned int	m_maxNModules = 0
std::vector< std::string >	m_modulesToExclude
unsigned int	m_nModules
unsigned int	m_nTimeSums = 0
const unsigned int	m_padding
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
const bool	m_trackGlobalBeginRun

Detailed Description

Definition at line 30 of file ConcurrentModuleTimer.cc.

Constructor & Destructor Documentation

ConcurrentModuleTimer()

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

Definition at line 73 of file ConcurrentModuleTimer.cc.

    : m_modulesToExclude(iConfig.getUntrackedParameter<std::vector<std::string>>("modulesToExclude")),
      m_time(),
      m_nModules(0),
      m_padding(iConfig.getUntrackedParameter<unsigned int>("padding")),
      m_spinLock{false},
      m_startedTiming(false),
      m_excludeSource(iConfig.getUntrackedParameter<bool>("excludeSource")),
      m_trackGlobalBeginRun(iConfig.getUntrackedParameter<bool>("trackGlobalBeginRun")) {
  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.watchPreModuleDestruction([this](ModuleDescription const& iMod) {
      auto found = std::find(m_excludedModuleIds.begin(), m_excludedModuleIds.end(), iMod.id());
      if (found != m_excludedModuleIds.end()) {
        m_excludedModuleIds.erase(found);
      }
    });
    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();
      }
    });
    if (m_trackGlobalBeginRun) {
      iReg.watchPreModuleGlobalBeginRun([this](GlobalContext const&, ModuleCallingContext const&) {
        if (not m_startedTiming) {
          m_time = std::chrono::high_resolution_clock::now();
          m_startedTiming = true;
        }

        start();
      });
      iReg.watchPostModuleGlobalBeginRun([this](GlobalContext const&, ModuleCallingContext const&) { stop(); });
    }
  }

  iReg.watchPreallocate([this](edm::service::SystemBounds const& iBounds) {
    m_nTimeSums = iBounds.maxNumberOfThreads() + 1 + m_padding;
    m_timeSums = std::make_unique<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::~ConcurrentModuleTimer

(

)

Definition at line 173 of file ConcurrentModuleTimer.cc.

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

                                              {
  std::cout << "Maximum concurrent running modules: " << m_maxNModules << std::endl;
  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

fillDescriptions()

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

static

Definition at line 262 of file ConcurrentModuleTimer.cc.

References edm::ConfigurationDescriptions::add(), and submitPVResolutionJobs::desc.

                                                                                       {
  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");
  desc.addUntracked<unsigned int>("padding", 0)
      ->setComment(
          "[Expert use only] Extra possible concurrent modules beyond thread count.\n Only useful in debugging "
          "possible framework scheduling problems.");
  desc.addUntracked<bool>("trackGlobalBeginRun", false)
      ->setComment("Check for concurrent modules during global begin run");
  descriptions.add("ConcurrentModuleTimer", desc);
}

start()

void ConcurrentModuleTimer::start ( )

private

Definition at line 201 of file ConcurrentModuleTimer.cc.

References cms::cuda::assert(), change_name::diff, mps_fire::i, m_maxNModules, m_nModules, m_nTimeSums, m_spinLock, m_time, m_timeSums, and submitPVValidationJobs::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;
    if (nModules > m_maxNModules) {
      m_maxNModules = 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());
  }
}

stop()

void ConcurrentModuleTimer::stop ( )

private

Definition at line 225 of file ConcurrentModuleTimer.cc.

References cms::cuda::assert(), change_name::diff, mps_fire::i, m_nModules, m_nTimeSums, m_spinLock, m_time, m_timeSums, and submitPVValidationJobs::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());
  }
}

trackModule()

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

private

Definition at line 249 of file ConcurrentModuleTimer.cc.

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

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

Member Data Documentation

m_excludedModuleIds

std::vector<unsigned int> edm::service::ConcurrentModuleTimer::m_excludedModuleIds

private

Definition at line 43 of file ConcurrentModuleTimer.cc.

Referenced by trackModule().

m_excludeSource

const bool edm::service::ConcurrentModuleTimer::m_excludeSource

private

Definition at line 51 of file ConcurrentModuleTimer.cc.

m_maxNModules

unsigned int edm::service::ConcurrentModuleTimer::m_maxNModules = 0

private

Definition at line 47 of file ConcurrentModuleTimer.cc.

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

m_modulesToExclude

std::vector<std::string> edm::service::ConcurrentModuleTimer::m_modulesToExclude

private

Definition at line 42 of file ConcurrentModuleTimer.cc.

m_nModules

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

private

Definition at line 46 of file ConcurrentModuleTimer.cc.

Referenced by start(), and stop().

m_nTimeSums

unsigned int edm::service::ConcurrentModuleTimer::m_nTimeSums = 0

private

Definition at line 45 of file ConcurrentModuleTimer.cc.

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

m_padding

const unsigned int edm::service::ConcurrentModuleTimer::m_padding

private

Definition at line 48 of file ConcurrentModuleTimer.cc.

m_spinLock

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

private

Definition at line 49 of file ConcurrentModuleTimer.cc.

Referenced by start(), and stop().

m_startedTiming

bool edm::service::ConcurrentModuleTimer::m_startedTiming

private

Definition at line 50 of file ConcurrentModuleTimer.cc.

m_time

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

private

Definition at line 44 of file ConcurrentModuleTimer.cc.

Referenced by start(), and stop().

m_timeSums

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

private

Definition at line 41 of file ConcurrentModuleTimer.cc.

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

m_trackGlobalBeginRun

const bool edm::service::ConcurrentModuleTimer::m_trackGlobalBeginRun

private

Definition at line 52 of file ConcurrentModuleTimer.cc.