timer.h

 
#ifndef CTRL_UTILS_TIMER_H_
#define CTRL_UTILS_TIMER_H_
 
#include <chrono>  // std::chrono
#include <thread>  // std::this_thread
 
namespace ctrl_utils {
 
class Timer {
 public:
  using Seconds = std::chrono::duration<double>;
  using Clock = std::chrono::steady_clock;
 
  Timer() {}
 
  Timer(double frequency) { set_freq(frequency); }
 
  double freq() const { return 1 / dt(); }
 
  void set_freq(double frequency) { set_dt(1. / frequency); }
 
  double dt() const {
    return std::chrono::duration_cast<Seconds>(dt_interval_).count();
  }
 
  void set_dt(double dt) {
    dt_interval_ = std::chrono::duration_cast<Clock::duration>(Seconds(dt));
  }
 
  double time(bool update = false) const {
    if (update) t_curr_ = Clock::now();
    return std::chrono::duration_cast<Seconds>(t_curr_.time_since_epoch())
        .count();
  }
 
  double time_elapsed(bool update = false) const {
    if (update) t_curr_ = Clock::now();
    return std::chrono::duration_cast<Seconds>(t_curr_ - t_start_).count();
  }
 
  double time_sim() const {
    return std::chrono::duration_cast<Seconds>(t_next_ - t_start_).count();
  }
 
  double average_freq() const { return (num_iters() - 1) / time_elapsed(); }
 
  unsigned long long num_iters() const { return num_iters_; }
 
  void Reset() {
    num_iters_ = 0;
    t_start_ = Clock::now();
    t_curr_ = t_start_;
    t_next_ = t_start_ + dt_interval_;
  }
 
  void Sleep() {
    t_curr_ = Clock::now();
    if (!initialized_) {
      t_start_ = t_curr_;
      t_next_ = t_curr_;
      initialized_ = true;
    }
 
    if (t_curr_ < t_next_) {
      std::this_thread::sleep_for(t_next_ - t_curr_);
    }
    t_next_ += dt_interval_;
    ++num_iters_;
  }
 
 private:
  Clock::time_point t_start_;
  mutable Clock::time_point t_curr_;
  Clock::time_point t_next_;
  unsigned long long num_iters_ = 0;
 
  bool initialized_ = false;
  Clock::duration dt_interval_ = std::chrono::milliseconds(1);
};
 
}  // namespace ctrl_utils
 
#endif  // CTRL_UTILS_TIMER_H_