ProcessStatistics.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/ModuleStatistics.h>
#include <framework/pcore/Mergeable.h>
#include <framework/core/Module.h>
 
#include <map>
#include <vector>
 
namespace Belle2 {
  class Module;
 
  class ProcessStatistics : public Mergeable {
  public:
    ProcessStatistics():
      m_global("Total"), m_globalTime(0), m_globalMemory(0), m_moduleTime(0), m_moduleMemory(0), m_suspendedTime(0),
      m_suspendedMemory(0) { }
 
    std::string getStatisticsString(ModuleStatistics::EStatisticCounters type = ModuleStatistics::c_Event,
                                    const std::vector<Belle2::ModuleStatistics>* modules = nullptr, bool html = false) const;
 
    const ModuleStatistics& getGlobal() const { return m_global; }
 
    const std::vector<Belle2::ModuleStatistics>& getAll() const { return m_stats; }
 
    void startGlobal() { setCounters(m_globalTime, m_globalMemory); }
 
    void suspendGlobal()
    {
      setCounters(m_suspendedTime, m_suspendedMemory,
                  m_globalTime, m_globalMemory);
    }
 
    void resumeGlobal()
    {
      setCounters(m_globalTime, m_globalMemory,
                  m_suspendedTime, m_suspendedMemory);
    }
 
    void stopGlobal(ModuleStatistics::EStatisticCounters type)
    {
      setCounters(m_globalTime, m_globalMemory,
                  m_globalTime, m_globalMemory);
      m_global.add(type, m_globalTime, m_globalMemory);
    }
 
    void startModule()
    {
      setCounters(m_moduleTime, m_moduleMemory);
    }
 
    void stopModule(const Module* module, ModuleStatistics::EStatisticCounters type)
    {
      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);
    }
 
    void initModule(const Module* module);
 
 
    ModuleStatistics& getStatistics(const Module* module)
    {
      return m_stats[getIndex(module)];
    }
 
    void write_csv(const char* filename = "ProcessStatistics.csv") const;
 
    int getIndex(const Module* module);
 
    virtual void merge(const Mergeable* other) override;
 
    virtual void clear() override;
 
    virtual TObject* Clone(const char* newname = "") const override;
 
    std::string getInfoHTML() const;
 
  private:
    ProcessStatistics(const ProcessStatistics&) = default;
    ProcessStatistics& operator=(ProcessStatistics&);
 
    void appendUnmergedModules(const ProcessStatistics* otherObject);
 
    void setTransientCounters(const ProcessStatistics* otherObject);
 
    void setCounters(double& time, double& memory,
                     double startTime = 0, double startMemory = 0);
 
    ModuleStatistics m_global; 
    std::vector<Belle2::ModuleStatistics> m_stats; 
    std::map<const Module*, int> m_modulesToStatsIndex; 
 
    //the following are used for the (process-local) time-keeping
 
    double m_globalTime; 
    double m_globalMemory; 
    double m_moduleTime; 
    double m_moduleMemory; 
    double m_suspendedTime; 
    double m_suspendedMemory; 
 
    ClassDefOverride(ProcessStatistics, 2); 
  };
 
} //Belle2 namespace