FastTimerService::PlotsPerElement Class Reference

Public Member Functions
void	book (dqm::reco::DQMStore::IBooker &, std::string const &name, std::string const &title, PlotRanges const &ranges, unsigned int lumisections, bool byls)
void	fill (AtomicResources const &, unsigned int lumisection)
void	fill (Resources const &, unsigned int lumisection)
void	fill_fraction (Resources const &, Resources const &, unsigned int lumisection)
	PlotsPerElement ()=default

Private Attributes
dqm::reco::MonitorElement *	allocated_
dqm::reco::MonitorElement *	allocated_byls_
dqm::reco::MonitorElement *	deallocated_
dqm::reco::MonitorElement *	deallocated_byls_
dqm::reco::MonitorElement *	time_real_
dqm::reco::MonitorElement *	time_real_byls_
dqm::reco::MonitorElement *	time_thread_
dqm::reco::MonitorElement *	time_thread_byls_

Detailed Description

Definition at line 325 of file FastTimerService.h.

Constructor & Destructor Documentation

PlotsPerElement()

FastTimerService::PlotsPerElement::PlotsPerElement ( )

default

Member Function Documentation

book()

void FastTimerService::PlotsPerElement::book	(	dqm::reco::DQMStore::IBooker &	booker,
		std::string const &	name,
		std::string const &	title,
		PlotRanges const &	ranges,
		unsigned int	lumisections,
		bool	byls
	)

Definition at line 372 of file FastTimerService.cc.

                                                        {
  int time_bins = (int)std::ceil(ranges.time_range / ranges.time_resolution);
  int mem_bins = (int)std::ceil(ranges.memory_range / ranges.memory_resolution);
  std::string y_title_ms = (boost::format("events / %.1f ms") % ranges.time_resolution).str();
  std::string y_title_kB = (boost::format("events / %.1f kB") % ranges.memory_resolution).str();
 
  time_thread_ =
      booker.book1D(name + " time_thread", title + " processing time (cpu)", time_bins, 0., ranges.time_range);
  time_thread_->setXTitle("processing time [ms]");
  time_thread_->setYTitle(y_title_ms);
 
  time_real_ = booker.book1D(name + " time_real", title + " processing time (real)", time_bins, 0., ranges.time_range);
  time_real_->setXTitle("processing time [ms]");
  time_real_->setYTitle(y_title_ms);
 
  if (memory_usage::is_available()) {
    allocated_ = booker.book1D(name + " allocated", title + " allocated memory", mem_bins, 0., ranges.memory_range);
    allocated_->setXTitle("memory [kB]");
    allocated_->setYTitle(y_title_kB);
 
    deallocated_ =
        booker.book1D(name + " deallocated", title + " deallocated memory", mem_bins, 0., ranges.memory_range);
    deallocated_->setXTitle("memory [kB]");
    deallocated_->setYTitle(y_title_kB);
  }
 
  if (not byls)
    return;
 
  time_thread_byls_ = booker.bookProfile(name + " time_thread_byls",
                                         title + " processing time (cpu) vs. lumisection",
                                         lumisections,
                                         0.5,
                                         lumisections + 0.5,
                                         time_bins,
                                         0.,
                                         std::numeric_limits<double>::infinity(),
                                         " ");
  time_thread_byls_->setXTitle("lumisection");
  time_thread_byls_->setYTitle("processing time [ms]");
 
  time_real_byls_ = booker.bookProfile(name + " time_real_byls",
                                       title + " processing time (real) vs. lumisection",
                                       lumisections,
                                       0.5,
                                       lumisections + 0.5,
                                       time_bins,
                                       0.,
                                       std::numeric_limits<double>::infinity(),
                                       " ");
  time_real_byls_->setXTitle("lumisection");
  time_real_byls_->setYTitle("processing time [ms]");
 
  if (memory_usage::is_available()) {
    allocated_byls_ = booker.bookProfile(name + " allocated_byls",
                                         title + " allocated memory vs. lumisection",
                                         lumisections,
                                         0.5,
                                         lumisections + 0.5,
                                         mem_bins,
                                         0.,
                                         std::numeric_limits<double>::infinity(),
                                         " ");
    allocated_byls_->setXTitle("lumisection");
    allocated_byls_->setYTitle("memory [kB]");
 
    deallocated_byls_ = booker.bookProfile(name + " deallocated_byls",
                                           title + " deallocated memory vs. lumisection",
                                           lumisections,
                                           0.5,
                                           lumisections + 0.5,
                                           mem_bins,
                                           0.,
                                           std::numeric_limits<double>::infinity(),
                                           " ");
    deallocated_byls_->setXTitle("lumisection");
    deallocated_byls_->setYTitle("memory [kB]");
  }
}

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::bookProfile(), reco::ceil(), dqm-mbProfile::format, infinity, createfilelist::int, memory_usage::is_available(), Skims_PA_cff::name, diffTwoXMLs::ranges, dqm::impl::MonitorElement::setXTitle(), str, AlCaHLTBitMon_QueryRunRegistry::string, and overlapproblemtsosanalyzer_cfi::title.

fill() [1/2]

void FastTimerService::PlotsPerElement::fill	(	AtomicResources const &	data,
		unsigned int	lumisection
	)

Definition at line 486 of file FastTimerService.cc.

                                                                                                {
  // enable underflows and overflows in the computation of mean and rms
  TH1::StatOverflows(true);
 
  if (time_thread_)
    time_thread_->Fill(ms(boost::chrono::nanoseconds(data.time_thread.load())));
 
  if (time_thread_byls_)
    time_thread_byls_->Fill(lumisection, ms(boost::chrono::nanoseconds(data.time_thread.load())));
 
  if (time_real_)
    time_real_->Fill(ms(boost::chrono::nanoseconds(data.time_real.load())));
 
  if (time_real_byls_)
    time_real_byls_->Fill(lumisection, ms(boost::chrono::nanoseconds(data.time_real.load())));
 
  if (allocated_)
    allocated_->Fill(kB(data.allocated));
 
  if (allocated_byls_)
    allocated_byls_->Fill(lumisection, kB(data.allocated));
 
  if (deallocated_)
    deallocated_->Fill(kB(data.deallocated));
 
  if (deallocated_byls_)
    deallocated_byls_->Fill(lumisection, kB(data.deallocated));
}

References data.

fill() [2/2]

void FastTimerService::PlotsPerElement::fill	(	Resources const &	data,
		unsigned int	lumisection
	)

Definition at line 457 of file FastTimerService.cc.

                                                                                          {
  // enable underflows and overflows in the computation of mean and rms
  TH1::StatOverflows(true);
 
  if (time_thread_)
    time_thread_->Fill(ms(data.time_thread));
 
  if (time_thread_byls_)
    time_thread_byls_->Fill(lumisection, ms(data.time_thread));
 
  if (time_real_)
    time_real_->Fill(ms(data.time_real));
 
  if (time_real_byls_)
    time_real_byls_->Fill(lumisection, ms(data.time_real));
 
  if (allocated_)
    allocated_->Fill(kB(data.allocated));
 
  if (allocated_byls_)
    allocated_byls_->Fill(lumisection, kB(data.allocated));
 
  if (deallocated_)
    deallocated_->Fill(kB(data.deallocated));
 
  if (deallocated_byls_)
    deallocated_byls_->Fill(lumisection, kB(data.deallocated));
}

References data.

fill_fraction()

void FastTimerService::PlotsPerElement::fill_fraction	(	Resources const &	data,
		Resources const &	part,
		unsigned int	lumisection
	)

Definition at line 515 of file FastTimerService.cc.

                                                                                {
  // enable underflows and overflows in the computation of mean and rms
  TH1::StatOverflows(true);
 
  float total;
  float fraction;
 
  total = ms(data.time_thread);
  fraction = (total > 0.) ? (ms(part.time_thread) / total) : 0.;
  if (time_thread_)
    time_thread_->Fill(total, fraction);
 
  if (time_thread_byls_)
    time_thread_byls_->Fill(lumisection, total, fraction);
 
  total = ms(data.time_real);
  fraction = (total > 0.) ? (ms(part.time_real) / total) : 0.;
  if (time_real_)
    time_real_->Fill(total, fraction);
 
  if (time_real_byls_)
    time_real_byls_->Fill(lumisection, total, fraction);
 
  total = kB(data.allocated);
  fraction = (total > 0.) ? (kB(part.allocated) / total) : 0.;
  if (allocated_)
    allocated_->Fill(total, fraction);
 
  if (allocated_byls_)
    allocated_byls_->Fill(lumisection, total, fraction);
 
  total = kB(data.deallocated);
  fraction = (total > 0.) ? (kB(part.deallocated) / total) : 0.;
  if (deallocated_)
    deallocated_->Fill(total, fraction);
 
  if (deallocated_byls_)
    deallocated_byls_->Fill(lumisection, total, fraction);
}

References data, HLT_2018_cff::fraction, and dqmMemoryStats::total.

Member Data Documentation

allocated_

dqm::reco::MonitorElement* FastTimerService::PlotsPerElement::allocated_

private

Definition at line 344 of file FastTimerService.h.

allocated_byls_

dqm::reco::MonitorElement* FastTimerService::PlotsPerElement::allocated_byls_

private

Definition at line 345 of file FastTimerService.h.

deallocated_

dqm::reco::MonitorElement* FastTimerService::PlotsPerElement::deallocated_

private

Definition at line 346 of file FastTimerService.h.

deallocated_byls_

dqm::reco::MonitorElement* FastTimerService::PlotsPerElement::deallocated_byls_

private

Definition at line 347 of file FastTimerService.h.

time_real_

dqm::reco::MonitorElement* FastTimerService::PlotsPerElement::time_real_

private

Definition at line 342 of file FastTimerService.h.

time_real_byls_

dqm::reco::MonitorElement* FastTimerService::PlotsPerElement::time_real_byls_

private

Definition at line 343 of file FastTimerService.h.

time_thread_

dqm::reco::MonitorElement* FastTimerService::PlotsPerElement::time_thread_

private

Definition at line 340 of file FastTimerService.h.

time_thread_byls_

dqm::reco::MonitorElement* FastTimerService::PlotsPerElement::time_thread_byls_

private

Definition at line 341 of file FastTimerService.h.