ThroughputService.cc

Go to the documentation of this file.

// C++ headers
#include <algorithm>
#include <chrono>

// boost headers
#include <boost/format.hpp>

// CMSSW headers
#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMServices/Core/interface/MonitorElement.h"
#include "ThroughputService.h"

// local headers
#include "processor_model.h"

// describe the module's configuration
void ThroughputService::fillDescriptions(edm::ConfigurationDescriptions & descriptions) {
  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);
}

ThroughputService::ThroughputService(const edm::ParameterSet & config, edm::ActivityRegistry & registry) :
  // 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;

void
ThroughputService::preallocate(edm::service::SystemBounds const& bounds)
{
  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)
{
  // 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)
{
  auto timestamp = std::chrono::steady_clock::now();
  m_sourced_events.fill( std::chrono::duration_cast<std::chrono::duration<double>>(timestamp - m_startup).count() );
}

void
ThroughputService::postEvent(edm::StreamContext const & sc)
{
  auto timestamp = std::chrono::steady_clock::now();
  m_retired_events.fill( std::chrono::duration_cast<std::chrono::duration<double>>(timestamp - m_startup).count() );
}


// declare ThroughputService as a framework Service
#include "FWCore/ServiceRegistry/interface/ServiceMaker.h"
DEFINE_FWK_SERVICE(ThroughputService);