CaMonitorData.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 "CaEnumArray.h"
#include "CaTimer.h"
 
#include <boost/serialization/access.hpp>
 
#include <algorithm>
 
namespace cbm::algo::ca
{
  template<class ECounterKey, class ETimerKey>
  class MonitorData {
   public:
    template<typename T>
    using CounterArray = EnumArray<ECounterKey, T>;

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

    MonitorData() = default;

    MonitorData(const MonitorData&) = default;

    MonitorData(MonitorData&&) = default;

    ~MonitorData() = default;

    MonitorData& operator=(const MonitorData&) = default;

    MonitorData& operator=(MonitorData&&) = default;

    void AddMonitorData(const MonitorData& other, bool parallel = false);

    int GetCounterValue(ECounterKey key) const { return faCounters[key]; }

    int GetNofCounters() const { return static_cast<int>(ECounterKey::END); }

    int GetNofTimers() const { return static_cast<int>(ETimerKey::END); }

    const Timer& GetTimer(ETimerKey key) const { return faTimers[key]; }

    void IncrementCounter(ECounterKey key) { ++faCounters[key]; };

    void IncrementCounter(ECounterKey key, int num) { faCounters[key] += num; }

    void Reset();

    void ResetCounter(ECounterKey key) { faCounters[key] = 0; }

    void StartTimer(ETimerKey key) { faTimers[key].Start(); }

    void StopTimer(ETimerKey key) { faTimers[key].Stop(); }
 
   private:
    friend class boost::serialization::access;
    template<typename Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& faTimers;
      ar& faCounters;
    }
 
    TimerArray<Timer> faTimers{};    
    CounterArray<int> faCounters{};  
  };
 
 
  // *****************************************
  // **  Template function implementations  **
  // *****************************************
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<class ECounterKey, class ETimerKey>
  inline void MonitorData<ECounterKey, ETimerKey>::AddMonitorData(const MonitorData<ECounterKey, ETimerKey>& other,
                                                                  bool parallel)
  {
    for (size_t iCounter = 0; iCounter < faCounters.size(); ++iCounter) {
      faCounters[iCounter] += other.faCounters[iCounter];
    }
    for (size_t iTimer = 0; iTimer < faTimers.size(); ++iTimer) {
      faTimers[iTimer].AddTimer(other.faTimers[iTimer], parallel);
    }
  }
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<class ECounterKey, class ETimerKey>
  inline void MonitorData<ECounterKey, ETimerKey>::Reset()
  {
    faCounters.fill(0);
    std::for_each(faTimers.begin(), faTimers.end(), [](auto& timer) { timer.Reset(); });
  }
}  // namespace cbm::algo::ca