TimingProfile.h

/* Distributed under the Apache License, Version 2.0.
   See accompanying NOTICE file for details.*/
 
#pragma once
 
#include "cdm/utils/Logger.h"
 
#include <chrono>
 
class CDM_DECL TimingProfile
{
  using Clock = std::chrono::high_resolution_clock;
public:
    TimingProfile() {}
    virtual ~TimingProfile() {}
 
    enum class State
    {
      Ready,      // Timer has no data and is not running
      Running,    // Timer is currently running
      Ran         // Timer has been stopped and has data
    };
 
    struct Timer
    {
      Clock::time_point start;
      Clock::time_point end;
      State state = State::Ready;
    };
 
    void Clear();
 
    Timer& GetTimer(const std::string& label);
 
    void Reset(Timer& timer);
    void Reset(const std::string& label)
    {
      return Reset(GetTimer(label));
    }
 
    void Start(Timer& timer);
    Timer& Start(const std::string& label)
    {
      Timer& timer = GetTimer(label);
      Start(timer);
      return timer;
    }
 
    void Stop(Timer& timer);
    void Stop(const std::string& label)
    {
      return Stop(GetTimer(label));
    }
 
    Clock::duration GetDuration(Timer& timer);
    Clock::duration GetDuration(const std::string& label)
    {
      return GetDuration(GetTimer(label));
    }
 
    double GetElapsedTime_s(Timer& timer);
    double GetElapsedTime_s(const std::string& label)
    {
      return GetElapsedTime_s(GetTimer(label));
    }
 
    template<typename Duration>
    typename Duration::rep GetElapsedTime(const Timer& timer)
    {
      if (timer.state == State::Running)
      {
          return std::chrono::duration_cast<Duration>(Clock::now() - timer.start).count();
      }
      else if (timer.state == State::Ran)
      {
          return std::chrono::duration_cast<Duration>(timer.end - timer.start).count();
      }
      else
      {
          return typename Duration::rep(0);
      }
    }
    template<typename Duration>
    typename Duration::rep GetElapsedTime(const std::string& label)
    {
      return GetElapsedTime<Duration>(GetTimer(label));
    }
 
private:
  std::map<std::string, Timer> m_timers;
};