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;

    void setStatisticsPrintStatus(ModuleStatistics::EStatisticCounters type, bool printStatus) { m_statsPrintStatus[type] = printStatus; }

    bool getStatisticsPrintStatus(ModuleStatistics::EStatisticCounters type) { return m_statsPrintStatus[type]; }
 
  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::array < bool, ModuleStatistics::EStatisticCounters::c_Total + 1 > m_statsPrintStatus{};

    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, 3); 
  };

} //Belle2 namespace