ProcessStatistics Class Reference

Class to collect call statistics for all modules. More...

#include <ProcessStatistics.h>

Inheritance diagram for ProcessStatistics:

Public Member Functions
	ProcessStatistics ()
	Constructor.
std::string	getStatisticsString (ModuleStatistics::EStatisticCounters type=ModuleStatistics::c_Event, const std::vector< Belle2::ModuleStatistics > *modules=nullptr, bool html=false) const
	Return string with statistics for all modules.
const ModuleStatistics &	getGlobal () const
	Get global statistics.
const std::vector< Belle2::ModuleStatistics > &	getAll () const
	Get entire statistics map.
void	startGlobal ()
	Start timer for global measurement.
void	suspendGlobal ()
	Suspend timer for global measurement, needed for newRun.
void	resumeGlobal ()
	Resume timer after call to suspendGlobal()
void	stopGlobal (ModuleStatistics::EStatisticCounters type)
	Stop global timer and add values to the statistic counter.
void	startModule ()
	Start module timer.
void	stopModule (const Module *module, ModuleStatistics::EStatisticCounters type)
	Stop module counter and attribute values to appropriate module.
void	initModule (const Module *module)
	Init module statistics: Set name from module if still empty and remember initialization index for display.
ModuleStatistics &	getStatistics (const Module *module)
	Get statistics for single module.
void	write_csv (const char *filename="ProcessStatistics.csv") const
	Write process statistics to a csv file.
int	getIndex (const Module *module)
	get m_stats index for given module, inserting it if not found.
virtual void	merge (const Mergeable *other) override
	Merge other ProcessStatistics object into this one.
virtual void	clear () override
	Clear collected statistics but keep names of modules.
virtual TObject *	Clone (const char *newname="") const override
	Reimplement TObject::Clone() since we also need m_modulesToStatsIndex.
std::string	getInfoHTML () const
	Return a short summary of this object's contents in HTML format.
virtual void	removeSideEffects ()
	An ugly little method that is called before event() for input and worker processes.
virtual Long64_t	Merge (TCollection *hlist)
	Allow merging using TFileMerger if saved directly to a file.
virtual void	Reset ()
	Root-like Reset function for "template compatibility" with ROOT objects.
virtual void	SetDirectory (TDirectory *)
	Root-like SetDirectory function for "template compatibility" with ROOT objects.

Private Member Functions
	ProcessStatistics (const ProcessStatistics &)=default
	Hide copy constructor.
ProcessStatistics &	operator= (ProcessStatistics &)
	Prohibit assignment operator.
void	appendUnmergedModules (const ProcessStatistics *otherObject)
	Merge dissimilar objects (mainly loading ProcessStatistics from file).
void	setTransientCounters (const ProcessStatistics *otherObject)
	Set transient counters from otherObject.
void	setCounters (double &time, double &memory, double startTime=0, double startMemory=0)
	Set counters time and memory to contain the current clock value and memory consumption respectively.
	ClassDefOverride (ProcessStatistics, 2)
	(transient)
	ClassDef (Mergeable, 0)
	Abstract base class for objects that can be merged.

Private Attributes
ModuleStatistics	m_global
	Statistics object for global time and memory consumption.
std::vector< Belle2::ModuleStatistics >	m_stats
	module statistics
std::map< const Module *, int >	m_modulesToStatsIndex
	transient, maps Module* to m_stats index.
double	m_globalTime
	store clock counter for global time consumption
double	m_globalMemory
	(transient)
double	m_moduleTime
	(transient)
double	m_moduleMemory
	(transient)
double	m_suspendedTime
	(transient)
double	m_suspendedMemory
	(transient)

Detailed Description

Class to collect call statistics for all modules.

This class is used to collect call and time statistics for all modules. It is implemented as a singleton and will keep track of the number of times a module will be called and the time the module spends in these calls.

Altough this class can be used in C++, its main purpose is to be used in python. In the python environment it is reachable through the "statistics" object in the pybasf2 module. Most simple use is to just print the event statistics after the process loop:

‍process(...) print(statistics)

Different types of statistics can be printed using

‍print(statistics(type))

where type can be one of

• statistics.INIT -> time/calls spent in initialize()
• statistics.BEGIN_RUN -> time/calls spent in beginRun()
• statistics.EVENT -> time/calls spent in event()
• statistics.END_RUN -> time/calls spent in endRun()
• statistics.TERM -> time/calls spent in terminate()
• statistics.TOTAL -> sum of all the above

It is also possible to restrict the event statistics to a list of modules one is interested in

‍foo = register_module("Foo") bar = register_module("Bar")

...

‍process(...) print(statistics([foo,bar])) print(statistics([foo,bar],statistics.BEGIN_RUN))

More detailed statistics can be reached by accessing the statistics for all modules directly:

‍process(...) for stats in statistics.modules: print(stats.name, stats.time(statistics.EVENT), stats.calls(statistics.BEGIN_RUN))

Available attributes/methods for the statistics objects are

• name: name of the module
• time(type=statistics.EVENT): time in seconds spent in function
• calls(type=statistics.EVENT): number of calls to function

The global statistics for the framework can be accessed via statistics.framework

The name shown in the statistics can be modified. This is particular useful if there is more than one instance of a given module in the path

‍foo = register_module("Foo") statistics.set_name(foo,"Footastic")

Definition at line 84 of file ProcessStatistics.h.

Constructor & Destructor Documentation

ProcessStatistics()

ProcessStatistics ( )

inline

Constructor.

Definition at line 87 of file ProcessStatistics.h.

                       :
      m_global("Total"), m_globalTime(0), m_globalMemory(0), m_moduleTime(0), m_moduleMemory(0), m_suspendedTime(0),
      m_suspendedMemory(0) { }

Member Function Documentation

appendUnmergedModules()

void appendUnmergedModules ( const ProcessStatistics *  otherObject )

private

Merge dissimilar objects (mainly loading ProcessStatistics from file).

Definition at line 119 of file ProcessStatistics.cc.

{
  unsigned int minIndexUnmerged = 0;
  if (otherObject->m_modulesToStatsIndex.empty()) {
    B2WARNING("ProcessStatistics::appendUnmergedModules(): Module -> index list is empty? This might produce wrong results");
  } else {
    minIndexUnmerged = otherObject->m_modulesToStatsIndex.begin()->second;
    for (auto pair : otherObject->m_modulesToStatsIndex) {
      if (pair.second < (int)minIndexUnmerged)
        minIndexUnmerged = pair.second;
    }
  }
  if (minIndexUnmerged > m_stats.size())
    B2FATAL("(minIndexUnmerged > m_stats.size()) :( ");
  if (minIndexUnmerged > otherObject->m_stats.size())
    B2FATAL("(minIndexUnmerged > otherObject->m_stats.size()) :( ");
 
 
  //the first minIndexUnmerged entries in m_stats should just be merged...
  for (unsigned int i = 0; i < minIndexUnmerged; i++) {
    ModuleStatistics& myStats = m_stats[i];
    const ModuleStatistics& otherStats = otherObject->m_stats[i];
    if (myStats.getName() == otherStats.getName()) {
      myStats.update(otherStats);
    } else {
      B2ERROR("mismatch in module names in statistics (" << myStats.getName() << " vs. " << otherStats.getName() <<
              "). ProcessStatistics::merge() can only merge statistics that contain exactly the same modules.");
    }
  }
 
  //append the rest
  for (unsigned int i = minIndexUnmerged; i < otherObject->m_stats.size(); i++) {
    const ModuleStatistics& otherStats = otherObject->m_stats[i];
    m_stats.emplace_back(otherStats);
    m_stats.back().setIndex(m_stats.size() - 1);
  }
  //copy m_modulesToStatsIndex
  //shift indices by #entries missing in otherObject
  const int shift = m_stats.size() - otherObject->m_stats.size();
  if (shift < 0) {
    B2FATAL("shift negative:" << LogVar("shift", shift));
  }
  for (auto pair : otherObject->m_modulesToStatsIndex) {
    m_modulesToStatsIndex[pair.first] = pair.second + shift;
  }
}

ClassDefOverride()

ClassDefOverride ( ProcessStatistics  , 2    )

private

(transient)

Class to collect call statistics for all modules.

clear()

void clear ( )

overridevirtual

Clear collected statistics but keep names of modules.

Implements Mergeable.

Definition at line 207 of file ProcessStatistics.cc.

{
  m_global.clear();
  for (auto& stats : m_stats) { stats.clear(); }
}

Clone()

TObject * Clone ( const char *  newname = "" ) const

overridevirtual

Reimplement TObject::Clone() since we also need m_modulesToStatsIndex.

Definition at line 220 of file ProcessStatistics.cc.

{
  auto* p = new ProcessStatistics(*this);
  return p;
}

getAll()

const std::vector< Belle2::ModuleStatistics > & getAll ( ) const

inline

Get entire statistics map.

Definition at line 108 of file ProcessStatistics.h.

{ return m_stats; }

getGlobal()

const ModuleStatistics & getGlobal ( ) const

inline

Get global statistics.

Definition at line 105 of file ProcessStatistics.h.

{ return m_global; }

getIndex()

int getIndex

(

const Module *

module

)

get m_stats index for given module, inserting it if not found.

Definition at line 27 of file ProcessStatistics.cc.

{
  auto indexIt = m_modulesToStatsIndex.find(module);
  if (indexIt == m_modulesToStatsIndex.end()) {
    int index = m_stats.size();
    m_modulesToStatsIndex[module] = index;
    m_stats.emplace_back();
    initModule(module);
    return index;
  } else {
    return indexIt->second;
  }
}

getInfoHTML()

std::string getInfoHTML

(

)

const

Return a short summary of this object's contents in HTML format.

Definition at line 226 of file ProcessStatistics.cc.

{
  std::string s = getStatisticsString();
  return "Event Statistics:<br />" + s;
}

getStatistics()

ModuleStatistics & getStatistics ( const Module *  module )

inline

Get statistics for single module.

Parameters

module

Shared pointer to the Module for which the statistics should be obtained

Definition at line 163 of file ProcessStatistics.h.

    {
      return m_stats[getIndex(module)];
    }

getStatisticsString()

string getStatisticsString	(	ModuleStatistics::EStatisticCounters	type = ModuleStatistics::c_Event,
		const std::vector< Belle2::ModuleStatistics > *	modules = nullptr,
		bool	html = false
	)		const

Return string with statistics for all modules.

Can be used in steering file with 'print(statistics)'.

Parameters

type	counter type to use for statistics
modules	map of modules to use. If NULL, default map will be used
html	if true return the output as html table instead of an ascii table

Definition at line 54 of file ProcessStatistics.cc.

{
  const ModuleStatistics& global = getGlobal();
  if (!modules) modules = &(getAll());
  int moduleNameLength = 21; //minimum: 80 characters
  const int lengthOfRest = 80 - moduleNameLength;
  for (const ModuleStatistics& stats : *modules) {
    int len = stats.getName().length();
    if (len > moduleNameLength)
      moduleNameLength = len;
  }
  const std::string numTabsModule = (boost::format("%d") % (moduleNameLength + 1)).str();
  const std::string numWidth = (boost::format("%d") % (moduleNameLength + 1 + lengthOfRest)).str();
  boost::format outputheader("%s %|" + numTabsModule + "t|| %10s | %10s | %10s | %17s\n");
  boost::format output("%s %|" + numTabsModule + "t|| %10.0f | %10.0f | %10.2f | %7.2f +-%7.2f\n");
  if (html) {
    outputheader = boost::format("<thead><tr><th>%s</th><th>%s</th><th>%s</th><th>%s</th><th>%s</th></tr></thead>");
    output = boost::format("<tr><td>%s</td><td>%.0f</td><td>%.0f</td><td>%.2f</td><td>%.2f &plusmn; %.2f</td></tr>");
  }
 
  stringstream out;
  if (!html) {
    out << boost::format("%|" + numWidth + "T=|\n");
    out << outputheader % "Name" % "Calls" % "Memory(MB)" % "Time(s)" % "Time(ms)/Call";
    out << boost::format("%|" + numWidth + "T=|\n");
  } else {
    out << "<table border=0>";
    out << outputheader % "Name" % "Calls" % "Memory(MB)" % "Time(s)" % "Time(ms)/Call";
    out << "<tbody>";
  }
 
  std::vector<ModuleStatistics> modulesSortedByIndex(*modules);
  sort(modulesSortedByIndex.begin(), modulesSortedByIndex.end(), [](const ModuleStatistics & a, const ModuleStatistics & b) { return a.getIndex() < b.getIndex(); });
 
  for (const ModuleStatistics& stats : modulesSortedByIndex) {
    out << output
        % stats.getName()
        % stats.getCalls(mode)
        % (stats.getMemorySum(mode) / 1024)
        % (stats.getTimeSum(mode) / Unit::s)
        % (stats.getTimeMean(mode) / Unit::ms)
        % (stats.getTimeStddev(mode) / Unit::ms);
  }
 
  if (!html) {
    out << boost::format("%|" + numWidth + "T=|\n");
  } else {
    out << "</tbody><tfoot>";
  }
  out << output
      % (ProcHandler::isOutputProcess() ? "Total (output proc.)" : "Total")
      % global.getCalls(mode)
      % (global.getMemorySum(mode) / 1024)
      % (global.getTimeSum(mode) / Unit::s)
      % (global.getTimeMean(mode) / Unit::ms)
      % (global.getTimeStddev(mode) / Unit::ms);
  if (!html) {
    out << boost::format("%|" + numWidth + "T=|\n");
  } else {
    out << "</tfoot></table>";
  }
  return out.str();
}

initModule()

void initModule

(

const Module *

module

)

Init module statistics: Set name from module if still empty and remember initialization index for display.

Definition at line 40 of file ProcessStatistics.cc.

{
  int index = getIndex(module);
  ModuleStatistics& stats = m_stats.at(index);
  if (module and stats.getName().empty()) {
    const string& type = module->getType();
    if (type == "Tx" or type == "Rx")
      stats.setName(type);
    else
      stats.setName(module->getName());
  }
  stats.setIndex(index);
}

merge()

void merge ( const Mergeable *  other )

overridevirtual

Merge other ProcessStatistics object into this one.

Implements Mergeable.

Definition at line 176 of file ProcessStatistics.cc.

{
  const auto* otherObject = static_cast<const ProcessStatistics*>(other);
 
  if (m_stats == otherObject->m_stats) {
    //fast version for merging between processes
    for (unsigned int i = 0; i < otherObject->m_stats.size(); i++)
      m_stats[i].update(otherObject->m_stats[i]);
  } else {
    //note: statistics in m_global are not merged for pp, we use the output process instead
    //for objects read from file we need to add them though
    m_global.update(otherObject->m_global);
 
    appendUnmergedModules(otherObject);
  }
 
  //if the other object has transient data on modules, copy remaining counters
  if (!otherObject->m_modulesToStatsIndex.empty())
    setTransientCounters(otherObject);
}

Merge()

Long64_t Merge ( TCollection *  hlist )

virtualinherited

Allow merging using TFileMerger if saved directly to a file.

Note

dictionaries containing your Mergeable class need to be loaded, so 'hadd' will not work currently.

Definition at line 14 of file Mergeable.cc.

{
  Long64_t nMerged = 0;
  if (hlist) {
    const Mergeable* xh = nullptr;
    TIter nxh(hlist);
    while ((xh = dynamic_cast<Mergeable*>(nxh()))) {
      // Add xh to me
      merge(xh);
      ++nMerged;
    }
  }
  return nMerged;
}

removeSideEffects()

virtual void removeSideEffects ( )

inlinevirtualinherited

An ugly little method that is called before event() for input and worker processes.

Main use case is to detach any attached TFile from this object. In the output process, it can stay attached (and grow as much as it likes).

Reimplemented in RootMergeable< T >.

Definition at line 58 of file Mergeable.h.

{}

Reset()

virtual void Reset ( )

inlinevirtualinherited

Root-like Reset function for "template compatibility" with ROOT objects.

Alias for clear().

Definition at line 66 of file Mergeable.h.

{clear();}

resumeGlobal()

void resumeGlobal ( )

inline

Resume timer after call to suspendGlobal()

Definition at line 123 of file ProcessStatistics.h.

    {
      setCounters(m_globalTime, m_globalMemory,
                  m_suspendedTime, m_suspendedMemory);
    }

setCounters()

void setCounters ( double &  time, double &  memory, double  startTime = 0, double  startMemory = 0  )

private

Set counters time and memory to contain the current clock value and memory consumption respectively.

Parameters

time	variable to store clock counter
memory	variable to store heap size
startTime	value to subtract from clock counter
startMemory	value to subtract from heap size

Definition at line 213 of file ProcessStatistics.cc.

{
  time = Utils::getClock() - startTime;
  memory = Utils::getRssMemoryKB() - startMemory;
}

SetDirectory()

virtual void SetDirectory ( TDirectory *  )

inlinevirtualinherited

Root-like SetDirectory function for "template compatibility" with ROOT objects.

Does nothing.

Definition at line 68 of file Mergeable.h.

{}

setTransientCounters()

void setTransientCounters ( const ProcessStatistics *  otherObject )

private

Set transient counters from otherObject.

Needed since we swap objects inside input modules.

Definition at line 197 of file ProcessStatistics.cc.

{
  m_globalTime = otherObject->m_globalTime;
  m_globalMemory = otherObject->m_globalMemory;
  m_moduleTime = otherObject->m_moduleTime;
  m_moduleMemory = otherObject->m_moduleMemory;
  m_suspendedTime = otherObject->m_suspendedTime;
  m_suspendedMemory = otherObject->m_suspendedMemory;
}

startGlobal()

void startGlobal ( )

inline

Start timer for global measurement.

Definition at line 111 of file ProcessStatistics.h.

{ setCounters(m_globalTime, m_globalMemory); }

startModule()

void startModule ( )

inline

Start module timer.

Definition at line 138 of file ProcessStatistics.h.

    {
      setCounters(m_moduleTime, m_moduleMemory);
    }

stopGlobal()

void stopGlobal ( ModuleStatistics::EStatisticCounters  type )

inline

Stop global timer and add values to the statistic counter.

Definition at line 130 of file ProcessStatistics.h.

    {
      setCounters(m_globalTime, m_globalMemory,
                  m_globalTime, m_globalMemory);
      m_global.add(type, m_globalTime, m_globalMemory);
    }

stopModule()

void stopModule ( const Module *  module, ModuleStatistics::EStatisticCounters  type  )

inline

Stop module counter and attribute values to appropriate module.

Definition at line 144 of file ProcessStatistics.h.

    {
      setCounters(m_moduleTime, m_moduleMemory,
                  m_moduleTime, m_moduleMemory);
      if (module && module->hasProperties(Module::c_DontCollectStatistics)) return;
      m_stats[getIndex(module)].add(type, m_moduleTime, m_moduleMemory);
    }

suspendGlobal()

void suspendGlobal ( )

inline

Suspend timer for global measurement, needed for newRun.

resumeGlobal should be called once endRun/newRun handling is finished

Definition at line 116 of file ProcessStatistics.h.

    {
      setCounters(m_suspendedTime, m_suspendedMemory,
                  m_globalTime, m_globalMemory);
    }

write_csv()

void write_csv

(

const char *

filename = "ProcessStatistics.csv"

)

const

Write process statistics to a csv file.

Definition at line 166 of file ProcessStatistics.cc.

{
  std::ofstream output(filename);
  m_global.csv_header(output);
  for (auto stats : m_stats) {
    stats.csv(output);
  }
  m_global.csv(output);
}

Member Data Documentation

m_global

ModuleStatistics m_global

private

Statistics object for global time and memory consumption.

Definition at line 208 of file ProcessStatistics.h.

m_globalMemory

double m_globalMemory

private

(transient)

store heap size for global memory consumption in KB

Definition at line 219 of file ProcessStatistics.h.

m_globalTime

double m_globalTime

private

store clock counter for global time consumption

Definition at line 217 of file ProcessStatistics.h.

m_moduleMemory

double m_moduleMemory

private

(transient)

store heap size for memory consumption by modules

Definition at line 223 of file ProcessStatistics.h.

m_modulesToStatsIndex

std::map<const Module*, int> m_modulesToStatsIndex

private

transient, maps Module* to m_stats index.

Definition at line 212 of file ProcessStatistics.h.

m_moduleTime

double m_moduleTime

private

(transient)

store clock counter for time consumption by modules

Definition at line 221 of file ProcessStatistics.h.

m_stats

std::vector<Belle2::ModuleStatistics> m_stats

private

module statistics

Definition at line 209 of file ProcessStatistics.h.

m_suspendedMemory

double m_suspendedMemory

private

(transient)

store heap size for suspended measurement. Generally this would be a stack of values but we know that we need at most one element so we keep it a plain double.

Definition at line 231 of file ProcessStatistics.h.

m_suspendedTime

double m_suspendedTime

private

(transient)

store clock counter for suspended measurement. Generally this would be a stack of values but we know that we need at most one element so we keep it a plain double.

Definition at line 227 of file ProcessStatistics.h.

---

The documentation for this class was generated from the following files:

• framework/core/include/ProcessStatistics.h
• framework/core/src/ProcessStatistics.cc