CaTimer.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 <boost/serialization/serialization.hpp>
 
#include <chrono>
#include <cstdint>
#include <iostream>
#include <limits>
#include <string>
 
namespace cbm::algo::ca
{
  class Timer {
   public:
    using Clock         = std::chrono::high_resolution_clock;
    using Duration      = std::chrono::nanoseconds;
    using DurationCount = Duration::rep;
    using TimePoint     = std::chrono::time_point<Clock, Duration>;
 
    Timer() = default;
 
    ~Timer() = default;
 
    Timer(const Timer&) = default;
 
    Timer(Timer&&) = default;
 
    Timer& operator=(const Timer&) = default;
 
    Timer& operator=(Timer&&) = default;
 
    void AddTimer(const Timer& other, bool parallel);
 
    double GetAverage() const { return static_cast<double>(fTotal) / fNofCalls * 1.e-9; }
 
    double GetMax() const { return static_cast<double>(fMax) * 1.e-9; }
 
    double GetMin() const { return static_cast<double>(fMin) * 1.e-9; }
 
    int GetNofCalls() const { return fNofCalls; }
 
    int GetMaxCallIndex() const { return fMaxCallIndex; }
 
    int GetMinCallIndex() const { return fMinCallIndex; }
 
    double GetTotal() const { return static_cast<double>(fTotal) * 1.e-9; }
 
    double GetTotalMs() const { return GetTotal() * 1.e3; }
 
    void Reset();
 
    void Start() { fStart = Clock::now(); }
 
    void Stop();
 
   private:
    friend class boost::serialization::access;
    template<typename Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fMin;
      ar& fMax;
      ar& fTotal;
      ar& fNofCalls;
      ar& fMinCallIndex;
      ar& fMaxCallIndex;
    }
 
    TimePoint fStart     = TimePoint();
    DurationCount fMin   = std::numeric_limits<DurationCount>::max();  
    DurationCount fMax   = std::numeric_limits<DurationCount>::min();  
    DurationCount fTotal = DurationCount(0);                           
    int fNofCalls        = 0;                                          
    int fMinCallIndex    = -1;                                         
    int fMaxCallIndex    = -1;                                         
  };                                                                   // class Timer
 
 
  // ************************************
  // **   Inline function definition   **
  // ************************************
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  inline void Timer::AddTimer(const Timer& other, bool parallel)
  {
    if (other.fMin < fMin) {
      fMin          = other.fMin;
      fMinCallIndex = other.fMinCallIndex + fNofCalls;
    }
    if (other.fMax > fMax) {
      fMax          = other.fMax;
      fMaxCallIndex = other.fMinCallIndex + fNofCalls;
    }
    if (parallel) {
      if (fTotal < other.fTotal) {
        fTotal = other.fTotal;
      }
    }
    else {
      fTotal += other.fTotal;
    }
    fNofCalls += other.fNofCalls;
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  inline void Timer::Reset()
  {
    fStart        = TimePoint();
    fMin          = std::numeric_limits<DurationCount>::max();
    fMax          = std::numeric_limits<DurationCount>::min();
    fMinCallIndex = -1;
    fMaxCallIndex = -1;
    fTotal        = DurationCount(0);
    fNofCalls     = 0;
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  inline void Timer::Stop()
  {
    auto stop = Clock::now();
    auto time = std::chrono::duration_cast<Duration>(stop - fStart).count();
    if (fMin > time) {
      fMin          = time;
      fMinCallIndex = fNofCalls;
    }
    if (fMax < time) {
      fMax          = time;
      fMaxCallIndex = fNofCalls;
    }
    fTotal += time;
    ++fNofCalls;
  }
}  // namespace cbm::algo::ca