execution_time_window_stats.hpp

Go to the documentation of this file.

/*
  _____                     _   _                 
 | ____|_  _____  ___ _   _| |_(_) ___  _ __  ___ 
 |  _| \ \/ / _ \/ __| | | | __| |/ _ \| '_ \/ __|
 | |___ >  <  __/ (__| |_| | |_| | (_) | | | \__ \
 |_____/_/\_\___|\___|\__,_|\__|_|\___/|_| |_|___/
 
Running window statistics for execution times.
*/
 
#ifndef EXECUTION_TIME_WINDOW_STATS_HPP
#define EXECUTION_TIME_WINDOW_STATS_HPP
 
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstddef>
#include <deque>
 
namespace Mads {
 
class ExecutionTimeWindowStats {
public:
  explicit ExecutionTimeWindowStats(std::size_t window_width = 100)
      : _window_width(window_width) {}
 
  void tic() {
    _start = clock_t::now();
    _ticking = true;
  }
 
  double toc() {
    const auto stop = clock_t::now();
    if (!_ticking) {
      return 0.0;
    }
    _ticking = false;
    const double elapsed_ms =
        std::chrono::duration<double, std::milli>(stop - _start).count();
    append_duration(elapsed_ms);
    return elapsed_ms;
  }
 
  void set_window_width(std::size_t window_width) {
    _window_width = window_width;
    trim_to_window();
  }
 
  std::size_t window_width() const { return _window_width; }
 
  std::size_t size() const { return _samples.size(); }
 
  double average_ms() const {
    if (_samples.empty()) {
      return 0.0;
    }
    return _sum / static_cast<double>(_samples.size());
  }
 
  double stddev_ms() const {
    if (_samples.empty()) {
      return 0.0;
    }
    const double n = static_cast<double>(_samples.size());
    const double mean = _sum / n;
    const double variance = std::max(0.0, (_sum_sq / n) - (mean * mean));
    return std::sqrt(variance);
  }
 
  void clear() {
    _samples.clear();
    _sum = 0.0;
    _sum_sq = 0.0;
    _ticking = false;
  }
 
private:
  using clock_t = std::chrono::steady_clock;
 
  void append_duration(double duration_ms) {
    if (_window_width == 0) {
      return;
    }
    _samples.push_back(duration_ms);
    _sum += duration_ms;
    _sum_sq += duration_ms * duration_ms;
    trim_to_window();
  }
 
  void trim_to_window() {
    while (_samples.size() > _window_width) {
      const double oldest = _samples.front();
      _samples.pop_front();
      _sum -= oldest;
      _sum_sq -= oldest * oldest;
    }
    if (_samples.empty()) {
      _sum = 0.0;
      _sum_sq = 0.0;
    }
  }
 
  std::size_t _window_width = 0;
  std::deque<double> _samples;
  double _sum = 0.0;
  double _sum_sq = 0.0;
  clock_t::time_point _start{};
  bool _ticking = false;
};
 
} // namespace Mads
 
#endif // EXECUTION_TIME_WINDOW_STATS_HPP