CaMonitor.h

Go to the documentation of this file.

/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#pragma once  // include this header only once per compilation unit
 
#include "CaEnumArray.h"
#include "CaMonitorData.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>
 
#include <algorithm>
#include <iomanip>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>
 
 
namespace cbm::algo::ca
{
  template<class ECounterKey, class ETimerKey = EDummy>
  class Monitor {
   public:
    template<typename T>
    using CounterArray = EnumArray<ECounterKey, T>;

    template<typename T>
    using TimerArray = EnumArray<ETimerKey, T>;

    Monitor(std::string_view name) : fsName(name) {}

    Monitor() = default;

    ~Monitor() = default;

    Monitor(const Monitor&) = delete;

    Monitor(Monitor&&) = delete;

    Monitor& operator=(const Monitor&) = delete;

    Monitor& operator=(Monitor&&) = delete;

    void AddMonitorData(const MonitorData<ECounterKey, ETimerKey>& data, bool parallel = false)
    {
      fMonitorData.AddMonitorData(data, parallel);
    }

    const std::string& GetCounterName(ECounterKey key) const { return faCounterNames[key]; }

    int GetCounterValue(ECounterKey key) const { return fMonitorData.GetCounterValue(key); }

    const MonitorData<ECounterKey, ETimerKey>& GetMonitorData() const { return fMonitorData; }

    const std::string& GetName() const { return fsName; }

    const Timer& GetTimer(ETimerKey key) const { return fMonitorData.GetTimer(key); }

    const std::string& GetTimerName(ETimerKey key) const { return faTimerNames[key]; }

    void IncrementCounter(ECounterKey key) { fMonitorData.IncrementCounter(key); };

    void IncrementCounter(ECounterKey key, int num) { fMonitorData.IncrementCounter(key, num); }

    void Reset() { fMonitorData.Reset(); }

    void SetRatioKeys(const std::vector<ECounterKey>& vKeys) { fvCounterRatioKeys = vKeys; }

    void SetCounterName(ECounterKey key, std::string_view name) { faCounterNames[key] = name; }

    void SetMonitorData(const MonitorData<ECounterKey, ETimerKey>& data) { fMonitorData = data; }

    void SetName(std::string_view name) { fsName = name; }

    void SetTimerName(ETimerKey key, std::string_view name) { faTimerNames[key] = name; }

    void StartTimer(ETimerKey key) { fMonitorData.StartTimer(key); }

    void StopTimer(ETimerKey key) { fMonitorData.StopTimer(key); }

    std::string ToString() const;
 
    friend class boost::serialization::access;
    template<typename Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fMonitorData;
      ar& faTimerNames;
      ar& faCounterNames;
      ar& fvCounterRatioKeys;
      ar& fsName;
    }
 
   private:
    MonitorData<ECounterKey, ETimerKey> fMonitorData;  
    TimerArray<std::string> faTimerNames{};            
    CounterArray<std::string> faCounterNames{};        
    std::vector<ECounterKey> fvCounterRatioKeys{};     
    std::string fsName;                                
  };
 
 
  // *****************************************
  // **  Template function implementations  **
  // *****************************************
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<class ECounterKey, class ETimerKey>
  std::string Monitor<ECounterKey, ETimerKey>::ToString() const
  {
    using std::left;
    using std::right;
    using std::setfill;
    using std::setw;
    std::stringstream msg;
    constexpr size_t width    = 24;
    auto Cmp                  = [](const std::string& l, const std::string& r) { return l.size() < r.size(); };
    msg << "\n===== Monitor: " << fsName << "\n";
    if constexpr (!std::is_same_v<ETimerKey, EDummy>) {
      size_t widthKeyTimer{std::max_element(faTimerNames.begin(), faTimerNames.end(), Cmp)->size() + 1};
      msg << "\n----- Timers:\n";
      msg << setw(widthKeyTimer) << left << "Key" << ' ';
      msg << setw(width) << left << "N Calls" << ' ';
      msg << setw(width) << left << "Average [s]" << ' ';
      msg << setw(width) << left << "Min [s]" << ' ';
      msg << setw(width) << left << "Max [s]" << ' ';
      msg << setw(width) << left << "Total [s]" << '\n';
      msg << right;
      for (int iKey = 0; iKey < fMonitorData.GetNofTimers(); ++iKey) {
        const Timer& timer = fMonitorData.GetTimer(static_cast<ETimerKey>(iKey));
        msg << setw(widthKeyTimer) << faTimerNames[iKey] << ' ';
        msg << setw(width) << std::fixed << std::setprecision(4) << timer.GetNofCalls() << ' ';
        msg << setw(width) << std::fixed << std::setprecision(4) << timer.GetAverage() << ' ';
        msg << setw(width) << std::fixed << std::setprecision(4) << timer.GetMin() << ' ';
        msg << setw(width) << std::fixed << std::setprecision(4) << timer.GetMax() << ' ';
        msg << setw(width) << std::fixed << std::setprecision(4) << timer.GetTotal() << '\n';
      }
    }
 
    msg << "\n----- Counters:\n";
    size_t widthKeyCounter{std::max_element(faCounterNames.begin(), faCounterNames.end(), Cmp)->size() + 1};
    msg << setw(widthKeyCounter) << left << "Key" << ' ';
    msg << setw(width) << left << "Total" << ' ';
    for (auto key : fvCounterRatioKeys) {
      msg << setw(width) << left << std::string("per ") + faCounterNames[key] << ' ';
    }
    msg << '\n';
    for (int iKey = 0; iKey < fMonitorData.GetNofCounters(); ++iKey) {
      auto counterValue = fMonitorData.GetCounterValue(static_cast<ECounterKey>(iKey));
      msg << setw(widthKeyCounter) << left << faCounterNames[iKey] << ' ';
      msg << setw(width) << right << counterValue << ' ';
      for (auto keyDen : fvCounterRatioKeys) {
        auto ratio = static_cast<double>(counterValue) / fMonitorData.GetCounterValue(keyDen);
        msg << setw(width) << right << ratio << ' ';
      }
      msg << '\n';
    }
    return msg.str();
  }
}  // namespace cbm::algo::ca