#include <ThroughputService.h>

Public Member Functions
	ThroughputService (const edm::ParameterSet &, edm::ActivityRegistry &)

	~ThroughputService ()

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

Private Member Functions
void	postEvent (edm::StreamContext const &sc)

void	preallocate (edm::service::SystemBounds const &bounds)

void	preGlobalBeginRun (edm::GlobalContext const &gc)

void	preSourceEvent (edm::StreamID sid)

Private Attributes
const bool	m_dqm_bynproc

std::string	m_dqm_path

ConcurrentMonitorElement	m_retired_events

ConcurrentMonitorElement	m_sourced_events

std::chrono::steady_clock::time_point	m_startup

const double	m_time_range

const double	m_time_resolution

Detailed Description

Definition at line 30 of file ThroughputService.h.

Constructor & Destructor Documentation

ThroughputService::ThroughputService	(	const edm::ParameterSet &	config,
		edm::ActivityRegistry &	registry
	)

Definition at line 26 of file ThroughputService.cc.

References postEvent(), preGlobalBeginRun(), preSourceEvent(), edm::ActivityRegistry::watchPostEvent(), edm::ActivityRegistry::watchPreGlobalBeginRun(), edm::ActivityRegistry::watchPreSourceEvent(), and ~ThroughputService().

                                                                                                    :
   // startup time
   m_startup(std::chrono::steady_clock::now()),
   // configuration
   m_time_range(      config.getUntrackedParameter<double>("timeRange") ),
   m_time_resolution( config.getUntrackedParameter<double>("timeResolution") ),
   m_dqm_path(        config.getUntrackedParameter<std::string>("dqmPath") ),
   m_dqm_bynproc(     config.getUntrackedParameter<bool>("dqmPathByProcesses") )
 {
   registry.watchPreGlobalBeginRun(  this, & ThroughputService::preGlobalBeginRun );
   registry.watchPreSourceEvent(     this, & ThroughputService::preSourceEvent );
   registry.watchPostEvent(          this, & ThroughputService::postEvent );
 }

ThroughputService::~ThroughputService ( )

default

Referenced by ThroughputService().

Member Function Documentation

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

static

Definition at line 17 of file ThroughputService.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), funct::false, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                     {
   edm::ParameterSetDescription desc;
   desc.addUntracked<double>(        "timeRange",       60000.0 );
   desc.addUntracked<double>(        "timeResolution",     10.0 );
   desc.addUntracked<std::string>(   "dqmPath",           "HLT/Throughput" );
   desc.addUntracked<bool>(          "dqmPathByProcesses", false );
   descriptions.add("ThroughputService", desc);
 }

void ThroughputService::postEvent ( edm::StreamContext const & sc )

private

Definition at line 88 of file ThroughputService.cc.

References KineDebug3::count(), DEFINE_FWK_SERVICE, ConcurrentMonitorElement::fill(), m_retired_events, m_startup, cmsPerfSuiteHarvest::now, and cond::timestamp.

Referenced by ThroughputService().

 {
   auto timestamp = std::chrono::steady_clock::now();
   m_retired_events.fill( std::chrono::duration_cast<std::chrono::duration<double>>(timestamp - m_startup).count() );
 }

void ThroughputService::preallocate ( edm::service::SystemBounds const & bounds )

private

Definition at line 43 of file ThroughputService.cc.

References cmsPerfStripChart::format, m_dqm_bynproc, m_dqm_path, edm::service::SystemBounds::maxNumberOfStreams(), edm::service::SystemBounds::maxNumberOfThreads(), processor_model, and str.

 {
   auto concurrent_streams = bounds.maxNumberOfStreams();
   auto concurrent_threads = bounds.maxNumberOfThreads();
 
   if (m_dqm_bynproc)
     m_dqm_path += (boost::format("/Running on %s with %d streams on %d threads") % processor_model % concurrent_streams % concurrent_threads).str();
 }

void ThroughputService::preGlobalBeginRun ( edm::GlobalContext const & gc )

private

Definition at line 53 of file ThroughputService.cc.

References create_public_pileup_plots::bins, MessageLogger_cfi::cerr, cmsPerfStripChart::format, edm::GlobalContext::luminosityBlockID(), m_dqm_path, m_retired_events, m_sourced_events, m_time_range, m_time_resolution, edm::LuminosityBlockID::run(), ConcurrentMonitorElement::setXTitle(), ConcurrentMonitorElement::setYTitle(), str, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ThroughputService().

 {
   // if the DQMStore is available, book the DQM histograms
   if (edm::Service<DQMStore>().isAvailable()) {
     std::string   y_axis_title = (boost::format("events / %g s") % m_time_resolution).str();
     unsigned int  bins         = std::round( m_time_range / m_time_resolution );
     double        range        = bins * m_time_resolution; 
 
     // define a callback that can book the histograms
     auto bookTransactionCallback = [&, this] (DQMStore::ConcurrentBooker & booker) {
       booker.setCurrentFolder(m_dqm_path);
       m_sourced_events = booker.book1D("throughput_sourced", "Throughput (sourced events)", bins, 0., range);
       m_sourced_events.setXTitle("time [s]");
       m_sourced_events.setYTitle(y_axis_title.c_str());
       m_retired_events = booker.book1D("throughput_retired", "Throughput (retired events)", bins, 0., range);
       m_retired_events.setXTitle("time [s]");
       m_retired_events.setYTitle(y_axis_title.c_str());
     };
 
     // book MonitorElement's for this run
     edm::Service<DQMStore>()->bookConcurrentTransaction(bookTransactionCallback, gc.luminosityBlockID().run());
   } else {
     std::cerr << "No DQMStore service, aborting." << std::endl;
     abort();
   }
 }

void ThroughputService::preSourceEvent ( edm::StreamID sid )

private

Definition at line 81 of file ThroughputService.cc.

References KineDebug3::count(), ConcurrentMonitorElement::fill(), m_sourced_events, m_startup, cmsPerfSuiteHarvest::now, and cond::timestamp.

Referenced by ThroughputService().

 {
   auto timestamp = std::chrono::steady_clock::now();
   m_sourced_events.fill( std::chrono::duration_cast<std::chrono::duration<double>>(timestamp - m_startup).count() );
 }