Belle II Software  release-05-01-25
StatisticsTimingHLTDQMModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2018 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Chunhua Li, Thomas Hauth, Nils Braun *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 #include <hlt/softwaretrigger/modules/dqm/StatisticsTimingHLTDQMModule.h>
11 #include <hlt/softwaretrigger/modules/dqm/SoftwareTriggerHLTDQMModule.h>
12 
13 #include <framework/datastore/StoreObjPtr.h>
14 #include <framework/core/ProcessStatistics.h>
15 #include <framework/core/ModuleStatistics.h>
16 #include <framework/gearbox/Unit.h>
17 
18 #include <TDirectory.h>
19 
20 #include <TH1F.h>
21 
22 #include <fstream>
23 
24 using namespace Belle2;
25 using namespace SoftwareTrigger;
26 
27 REG_MODULE(StatisticsTimingHLTDQM)
28 
30 {
31  setDescription("Monitor reconstruction runtime on HLT");
32  setPropertyFlags(c_ParallelProcessingCertified);
33 
34  addParam("histogramDirectoryName", m_param_histogramDirectoryName,
35  "Runtime DQM histograms on HLT will be put into this directory", m_param_histogramDirectoryName);
36 
37  addParam("m_param_overviewModuleList", m_param_overviewModuleList,
38  "Which modules should be shown in the overview mean list", m_param_overviewModuleList);
39 
40  addParam("createHLTUnitHistograms", m_param_create_hlt_unit_histograms,
41  "Create HLT unit histograms?",
42  false);
43 }
44 
46 {
47  // Create a separate histogram directory and cd into it.
48  TDirectory* oldDirectory = nullptr;
49 
50  if (!m_param_histogramDirectoryName.empty()) {
51  oldDirectory = gDirectory;
52  TDirectory* histDir = oldDirectory->mkdir(m_param_histogramDirectoryName.c_str());
53  histDir->cd();
54  }
55 
56  m_meanTimeHistogram = new TH1F("meanTimeHistogram", "Mean Processing Time [ms]", m_param_overviewModuleList.size(), 0,
58  m_meanTimeHistogram->SetStats(false);
59  m_meanMemoryHistogram = new TH1F("meanMemoryHistogram", "Mean Memory [KB]", m_param_overviewModuleList.size(), 0,
61  m_meanMemoryHistogram->SetStats(false);
62  m_fullTimeHistogram = new TH1F("fullTimeHistogram", "Budget Time [ms]", m_fullTimeNBins, 0, m_fullTimeMax);
63  m_fullTimeHistogram->StatOverflows(true);
64  m_processingTimeHistogram = new TH1F("processingTimeHistogram", "Processing Time [ms]", m_processingTimeNBins, 0,
66  m_processingTimeHistogram->StatOverflows(true);
67  m_fullMemoryHistogram = new TH1F("fullMemoryHistogram", "Total memory used [KB]", m_fullMemoryNBins, m_fullMemoryMin,
69  m_fullMemoryHistogram->StatOverflows(true);
70  m_processingMemoryHistogram = new TH1F("processingMemoryHistogram", "Memory used for processing [KB]", m_processingMemoryNBins,
73  m_processingMemoryHistogram->StatOverflows(true);
74 
75  for (unsigned int index = 0; index < m_param_overviewModuleList.size(); index++) {
76  const std::string& moduleName = m_param_overviewModuleList[index];
77  m_meanTimeHistogram->GetXaxis()->SetBinLabel(index + 1, moduleName.c_str());
78  m_meanMemoryHistogram->GetXaxis()->SetBinLabel(index + 1, moduleName.c_str());
79  m_moduleTimeHistograms.emplace(moduleName, new TH1F((moduleName + "_time").c_str(),
80  ("Time spent in: " + moduleName + " [ms]").c_str(), m_processingTimeNBins, 0, m_processingTimeMax));
81  m_moduleTimeHistograms[moduleName]->StatOverflows(true);
82  m_lastModuleTimeSum.emplace(moduleName, 0);
83  m_moduleMemoryHistograms.emplace(moduleName, new TH1F((moduleName + "_memory").c_str(),
84  ("Memory used in: " + moduleName + " [KB]").c_str(), m_processingMemoryNBins, m_processingMemoryMin, m_processingMemoryMax));
85  m_moduleMemoryHistograms[moduleName]->StatOverflows(true);
86  m_lastModuleMemorySum.emplace(moduleName, 0);
87  }
88 
90  m_fullTimeMeanPerUnitHistogram = new TH1F("fullTimeMeanPerUnitHistogram", "Mean Budget Time Per Unit [ms]",
93  m_fullTimeMeanPerUnitHistogram->SetStats(false);
94  m_fullTimeMeanPerUnitHistogram->SetXTitle("HLT unit number");
95  m_processingTimeMeanPerUnitHistogram = new TH1F("processingTimeMeanPerUnitHistogram", "Mean Processing Time Per Unit [ms]",
98  m_processingTimeMeanPerUnitHistogram->SetStats(false);
99  m_processingTimeMeanPerUnitHistogram->SetXTitle("HLT unit number");
100 
101  for (unsigned int index = 1; index <= HLTUnit::max_hlt_units; index++) {
102  m_fullTimePerUnitHistograms.emplace(index, new TH1F(("fullTimePerUnitHistogram_HLT" + std::to_string(index)).c_str(),
103  ("Budget Time Per Unit: HLT" + std::to_string(index) + " [ms]").c_str(), m_fullTimeNBins, 0, m_fullTimeMax));
104  m_fullTimePerUnitHistograms[index]->StatOverflows(true);
105  m_lastFullTimeSumPerUnit.emplace(index, 0);
106  m_processingTimePerUnitHistograms.emplace(index, new TH1F(("processingTimePerUnitHistogram_HLT" + std::to_string(index)).c_str(),
107  ("Processing Time Per Unit: HLT" + std::to_string(index) + " [ms]").c_str(), m_processingTimeNBins, 0, m_processingTimeMax));
108  m_processingTimePerUnitHistograms[index]->StatOverflows(true);
109  m_lastProcessingTimeSumPerUnit.emplace(index, 0);
110  m_fullMemoryPerUnitHistograms.emplace(index, new TH1F(("fullMemoryPerUnitHistogram_HLT" + std::to_string(index)).c_str(),
111  ("Total Memory Used Per Unit: HLT" + std::to_string(index) + " [KB]").c_str(), m_fullMemoryNBins, m_fullMemoryMin,
112  m_fullMemoryMax));
113  m_fullMemoryPerUnitHistograms[index]->StatOverflows(true);
114  m_lastFullMemorySumPerUnit.emplace(index, 0);
116  new TH1F(("processingMemoryPerUnitHistogram_HLT" + std::to_string(index)).c_str(),
117  ("Memory Used For Processing Per Unit: HLT" + std::to_string(index) + " [KB]").c_str(), m_processingMemoryNBins,
120  m_processingMemoryPerUnitHistograms[index]->StatOverflows(true);
121  m_lastProcessingMemorySumPerUnit.emplace(index, 0);
122  }
123 
124  m_processesPerUnitHistogram = new TH1F("processesPerUnitHistogram", "Number of Processes Per Unit",
125  HLTUnit::max_hlt_units + 1, 0,
127  m_processesPerUnitHistogram->SetStats(false);
128  }
129 
130  if (oldDirectory) {
131  oldDirectory->cd();
132  }
133 }
134 
135 
137 {
138  // Register histograms (calls back defineHisto)
139  REG_HISTOGRAM
140 
142  std::ifstream file;
143  file.open(HLTUnit::hlt_unit_file);
144  if (file.good()) {
145  std::string host;
146  getline(file, host);
147  m_hlt_unit = atoi(host.substr(3, 2).c_str());
148  file.close();
149  } else {
150  B2WARNING("HLT unit number not found");
151  }
152  }
153 }
154 
156 {
158 
159  if (not stats.isValid()) {
160  return;
161  }
162 
163  const std::vector<ModuleStatistics>& moduleStatisticsList = stats->getAll();
164 
165  std::vector<double> meanTimes(m_param_overviewModuleList.size(), 0);
166  std::vector<double> meanMemories(m_param_overviewModuleList.size(), 0);
167 
168  for (const ModuleStatistics& moduleStatistics : moduleStatisticsList) {
169  const std::string& statisticsName = moduleStatistics.getName();
170  const auto m_param_overviewModuleListIterator = std::find(m_param_overviewModuleList.begin(), m_param_overviewModuleList.end(),
171  statisticsName);
172  if (m_param_overviewModuleListIterator == m_param_overviewModuleList.end()) {
173  continue;
174  }
175 
176  const double statisticsTime = moduleStatistics.getTimeMean(ModuleStatistics::EStatisticCounters::c_Event) / Unit::ms;
177  const double statisticsMemory = moduleStatistics.getMemoryMean(ModuleStatistics::EStatisticCounters::c_Event);
178  const double statisticsTime_sum = moduleStatistics.getTimeSum(ModuleStatistics::EStatisticCounters::c_Event) / Unit::ms;
179  const double statisticsMemory_sum = moduleStatistics.getMemorySum(ModuleStatistics::EStatisticCounters::c_Event);
180 
181  const int m_param_overviewModuleListIndex = std::distance(m_param_overviewModuleList.begin(), m_param_overviewModuleListIterator);
182  meanTimes[m_param_overviewModuleListIndex] += statisticsTime;
183  meanMemories[m_param_overviewModuleListIndex] += statisticsMemory;
184 
185  m_moduleTimeHistograms[statisticsName]->Fill(statisticsTime_sum - m_lastModuleTimeSum[statisticsName]);
186  m_lastModuleTimeSum[statisticsName] = statisticsTime_sum;
187  m_moduleMemoryHistograms[statisticsName]->Fill(statisticsMemory_sum - m_lastModuleMemorySum[statisticsName]);
188  m_lastModuleMemorySum[statisticsName] = statisticsMemory_sum;
189  }
190 
191  for (unsigned int index = 0; index < m_param_overviewModuleList.size(); index++) {
192  m_meanTimeHistogram->SetBinContent(index + 1, meanTimes[index]);
193  m_meanMemoryHistogram->SetBinContent(index + 1, meanMemories[index]);
194  }
195 
196  double processingTimeSum = 0.0;
197  double processingTimeMean = 0.0;
198  double processingMemorySum = 0.0;
199  for (const ModuleStatistics& moduleStatistics : moduleStatisticsList) {
200  const std::string& statisticsName = moduleStatistics.getName();
201  const auto m_summaryModuleListIterator = std::find(m_summaryModuleList.begin(), m_summaryModuleList.end(),
202  statisticsName);
203  if (m_summaryModuleListIterator == m_summaryModuleList.end()) {
204  continue;
205  }
206  processingTimeSum += moduleStatistics.getTimeSum(ModuleStatistics::EStatisticCounters::c_Event) / Unit::ms;
207  processingTimeMean += moduleStatistics.getTimeMean(ModuleStatistics::EStatisticCounters::c_Event) / Unit::ms;
208  processingMemorySum += moduleStatistics.getMemorySum(ModuleStatistics::EStatisticCounters::c_Event);
209  }
210  m_processingTimeHistogram->Fill(processingTimeSum - m_lastProcessingTimeSum);
211  m_lastProcessingTimeSum = processingTimeSum;
212  m_processingMemoryHistogram->Fill(processingMemorySum - m_lastProcessingMemorySum);
213  m_lastProcessingMemorySum = processingMemorySum;
214 
215  const ModuleStatistics& fullStatistics = stats->getGlobal();
216  const double fullTimeSum = fullStatistics.getTimeSum(ModuleStatistics::EStatisticCounters::c_Event) / Unit::ms;
217  m_fullTimeHistogram->Fill(fullTimeSum - m_lastFullTimeSum);
218  m_lastFullTimeSum = fullTimeSum;
219  const double fullMemorySum = fullStatistics.getMemorySum(ModuleStatistics::EStatisticCounters::c_Event);
220  m_fullMemoryHistogram->Fill(fullMemorySum - m_lastFullMemorySum);
221  m_lastFullMemorySum = fullMemorySum;
222 
224  if (0 < m_hlt_unit) {
225  m_processingTimeMeanPerUnitHistogram->SetBinContent(m_hlt_unit + 1, processingTimeMean);
226 
228  m_lastProcessingTimeSumPerUnit[m_hlt_unit] = processingTimeSum;
229 
231  m_lastProcessingMemorySumPerUnit[m_hlt_unit] = processingMemorySum;
232 
233  const double fullTimeMean = fullStatistics.getTimeMean(ModuleStatistics::EStatisticCounters::c_Event) / Unit::ms;
234  m_fullTimeMeanPerUnitHistogram->SetBinContent(m_hlt_unit + 1, fullTimeMean);
235 
237  m_lastFullTimeSumPerUnit[m_hlt_unit] = fullTimeSum;
238 
240  m_lastFullMemorySumPerUnit[m_hlt_unit] = fullMemorySum;
241  }
242  }
243 }
244 
246 {
248  B2FATAL("Histograms were not created. Did you setup a HistoManager?");
249  }
250 
251  m_meanTimeHistogram->Reset();
252  m_meanMemoryHistogram->Reset();
253  std::for_each(m_moduleTimeHistograms.begin(), m_moduleTimeHistograms.end(),
254  [](auto & it) { it.second->Reset(); });
255  std::for_each(m_moduleMemoryHistograms.begin(), m_moduleMemoryHistograms.end(),
256  [](auto & it) { it.second->Reset(); });
257  m_fullTimeHistogram->Reset();
258  m_processingTimeHistogram->Reset();
259  m_fullMemoryHistogram->Reset();
264  std::for_each(m_fullTimePerUnitHistograms.begin(), m_fullTimePerUnitHistograms.end(),
265  [](auto & it) { it.second->Reset(); });
267  [](auto & it) { it.second->Reset(); });
269  [](auto & it) { it.second->Reset(); });
271  [](auto & it) { it.second->Reset(); });
273 
275  }
276 }
277 
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::event
void event() override
Full the histograms.
Definition: StatisticsTimingHLTDQMModule.cc:155
Belle2::Unit::ms
static const double ms
[millisecond]
Definition: Unit.h:106
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_param_overviewModuleList
std::vector< std::string > m_param_overviewModuleList
Parameter: which modules should be shown in the overview list.
Definition: StatisticsTimingHLTDQMModule.h:128
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingTimeMax
const double m_processingTimeMax
Maximum for the histograms of processingTime.
Definition: StatisticsTimingHLTDQMModule.h:143
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullMemoryHistogram
TH1F * m_fullMemoryHistogram
Total memory usage distribution of all events.
Definition: StatisticsTimingHLTDQMModule.h:65
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingMemoryHistogram
TH1F * m_processingMemoryHistogram
Memory used for processing distribution of all events.
Definition: StatisticsTimingHLTDQMModule.h:68
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingTimeHistogram
TH1F * m_processingTimeHistogram
Processing time distribution of all events.
Definition: StatisticsTimingHLTDQMModule.h:62
Belle2::SoftwareTrigger::HLTUnit::max_hlt_units
static constexpr unsigned int max_hlt_units
Maximum number of HLT units used during the experiment.
Definition: SoftwareTriggerHLTDQMModule.h:135
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::initialize
void initialize() override
Define the histograms.
Definition: StatisticsTimingHLTDQMModule.cc:136
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingTimeNBins
const double m_processingTimeNBins
Number of bins for the histograms of processingTime.
Definition: StatisticsTimingHLTDQMModule.h:146
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastModuleTimeSum
std::map< std::string, double > m_lastModuleTimeSum
Storage for the last time sum of certain modules.
Definition: StatisticsTimingHLTDQMModule.h:104
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastFullMemorySumPerUnit
std::map< unsigned int, double > m_lastFullMemorySumPerUnit
Storage for the last full memory sum per unit.
Definition: StatisticsTimingHLTDQMModule.h:110
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullTimeMeanPerUnitHistogram
TH1F * m_fullTimeMeanPerUnitHistogram
Mean budget time of events per unit.
Definition: StatisticsTimingHLTDQMModule.h:71
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingTimePerUnitHistograms
std::map< unsigned int, TH1F * > m_processingTimePerUnitHistograms
Processing time distribution of events per unit.
Definition: StatisticsTimingHLTDQMModule.h:80
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullTimePerUnitHistograms
std::map< unsigned int, TH1F * > m_fullTimePerUnitHistograms
Budget time distribution of events per unit.
Definition: StatisticsTimingHLTDQMModule.h:77
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingMemoryNBins
const double m_processingMemoryNBins
Number of bins for the histograms of processingMemory.
Definition: StatisticsTimingHLTDQMModule.h:164
Belle2::ModuleStatistics::getMemorySum
value_type getMemorySum(EStatisticCounters type=c_Total) const
return the total used memory for a given counter
Definition: ModuleStatistics.h:112
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::defineHisto
void defineHisto() override
Histogram definition.
Definition: StatisticsTimingHLTDQMModule.cc:45
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_meanMemoryHistogram
TH1F * m_meanMemoryHistogram
Mean memory of certain modules.
Definition: StatisticsTimingHLTDQMModule.h:50
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::beginRun
void beginRun() override
Reset histogram entries.
Definition: StatisticsTimingHLTDQMModule.cc:245
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastFullTimeSumPerUnit
std::map< unsigned int, double > m_lastFullTimeSumPerUnit
Storage for the last full time sum per unit.
Definition: StatisticsTimingHLTDQMModule.h:95
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullTimeNBins
const double m_fullTimeNBins
Number of bins for the histograms of fullTime.
Definition: StatisticsTimingHLTDQMModule.h:140
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_moduleMemoryHistograms
std::map< std::string, TH1F * > m_moduleMemoryHistograms
Memory distribution of certain modules.
Definition: StatisticsTimingHLTDQMModule.h:56
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullMemoryMax
const double m_fullMemoryMax
Maximum for the histograms of fullMemory.
Definition: StatisticsTimingHLTDQMModule.h:152
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullTimeMax
const double m_fullTimeMax
Maximum for the histograms of fullTime.
Definition: StatisticsTimingHLTDQMModule.h:137
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_moduleTimeHistograms
std::map< std::string, TH1F * > m_moduleTimeHistograms
Time distribution of certain modules.
Definition: StatisticsTimingHLTDQMModule.h:53
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_param_create_hlt_unit_histograms
bool m_param_create_hlt_unit_histograms
Parameter: Create HLT unit number histograms?
Definition: StatisticsTimingHLTDQMModule.h:122
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullTimeHistogram
TH1F * m_fullTimeHistogram
Budget time distribution of all events.
Definition: StatisticsTimingHLTDQMModule.h:59
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastProcessingTimeSum
double m_lastProcessingTimeSum
Storage for the last processing time sum.
Definition: StatisticsTimingHLTDQMModule.h:98
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastProcessingMemorySum
double m_lastProcessingMemorySum
Storage for the last processing memory sum.
Definition: StatisticsTimingHLTDQMModule.h:113
Belle2::SoftwareTrigger::HLTUnit::hlt_unit_file
static constexpr char hlt_unit_file[]
Location of HLT unit number information.
Definition: SoftwareTriggerHLTDQMModule.h:138
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingTimeMeanPerUnitHistogram
TH1F * m_processingTimeMeanPerUnitHistogram
Mean processing time of events per unit.
Definition: StatisticsTimingHLTDQMModule.h:74
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingMemoryMin
const double m_processingMemoryMin
Minimum for the histograms of processingMemory.
Definition: StatisticsTimingHLTDQMModule.h:158
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processesPerUnitHistogram
TH1F * m_processesPerUnitHistogram
Number of processes per unit.
Definition: StatisticsTimingHLTDQMModule.h:89
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastModuleMemorySum
std::map< std::string, double > m_lastModuleMemorySum
Storage for the last memory sum of certain modules.
Definition: StatisticsTimingHLTDQMModule.h:119
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_summaryModuleList
std::vector< std::string > m_summaryModuleList
Summary modules of the actual processing.
Definition: StatisticsTimingHLTDQMModule.h:131
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_meanTimeHistogram
TH1F * m_meanTimeHistogram
Mean time of certain modules.
Definition: StatisticsTimingHLTDQMModule.h:47
Belle2::DataStore::c_Persistent
@ c_Persistent
Object is available during entire execution time.
Definition: DataStore.h:62
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingMemoryPerUnitHistograms
std::map< unsigned int, TH1F * > m_processingMemoryPerUnitHistograms
Memory used for processing distribution of events per unit.
Definition: StatisticsTimingHLTDQMModule.h:86
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_hlt_unit
int m_hlt_unit
Store HLT unit number on initialization.
Definition: StatisticsTimingHLTDQMModule.h:134
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastProcessingMemorySumPerUnit
std::map< unsigned int, double > m_lastProcessingMemorySumPerUnit
Storage for the last processing memory sum per unit.
Definition: StatisticsTimingHLTDQMModule.h:116
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullMemoryPerUnitHistograms
std::map< unsigned int, TH1F * > m_fullMemoryPerUnitHistograms
Total memory distribution of events per unit.
Definition: StatisticsTimingHLTDQMModule.h:83
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_param_histogramDirectoryName
std::string m_param_histogramDirectoryName
Parameter: Directory to put the generated histograms.
Definition: StatisticsTimingHLTDQMModule.h:125
Belle2::ModuleStatistics::getTimeMean
value_type getTimeMean(EStatisticCounters type=c_Total) const
return the mean execution time for a given counter
Definition: ModuleStatistics.h:102
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullMemoryNBins
const double m_fullMemoryNBins
Number of bins for the histograms of fullMemory.
Definition: StatisticsTimingHLTDQMModule.h:155
Belle2::ModuleStatistics::getTimeSum
value_type getTimeSum(EStatisticCounters type=c_Total) const
return the sum of all execution times for a given counter
Definition: ModuleStatistics.h:97
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastFullMemorySum
double m_lastFullMemorySum
Storage for the last full memory sum.
Definition: StatisticsTimingHLTDQMModule.h:107
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_fullMemoryMin
const double m_fullMemoryMin
Minimum for the histograms of fullMemory.
Definition: StatisticsTimingHLTDQMModule.h:149
Belle2::HistoModule
HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions t...
Definition: HistoModule.h:29
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastProcessingTimeSumPerUnit
std::map< unsigned int, double > m_lastProcessingTimeSumPerUnit
Storage for the last processing time sum per unit.
Definition: StatisticsTimingHLTDQMModule.h:101
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_lastFullTimeSum
double m_lastFullTimeSum
Storage for the last full time sum.
Definition: StatisticsTimingHLTDQMModule.h:92
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule::m_processingMemoryMax
const double m_processingMemoryMax
Maximum for the histograms of processingMemory.
Definition: StatisticsTimingHLTDQMModule.h:161
Belle2::SoftwareTrigger::StatisticsTimingHLTDQMModule
Module for Event Time Statistics DQM plots.
Definition: StatisticsTimingHLTDQMModule.h:28
Belle2::ModuleStatistics
Keep track of time and memory consumption during processing.
Definition: ModuleStatistics.h:36