rate_counter.hpp

#pragma once
 
#include <memory>
#include <deque>
#include <numeric>
#include <iostream>
 
#include "../global.hpp"
#include "utilities.hpp"
#include "stop_watch.hpp"
 
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace Utilities
{
 
 
class RateCounter
{
  public:
 
 
  
    static constexpr int MinimumWindowSize = 1;
 
    static constexpr int DefaultWindowSize = 25;
 
    static constexpr int MaximumWindowSize = 65535;
 
 
    static std::unique_ptr<RateCounter> Create()
    {
      return std::unique_ptr<RateCounter>();
    }
 
 
    static std::unique_ptr<RateCounter> Create(int windowSize)
    {
      return std::make_unique<RateCounter>(windowSize);
    }
 
 
    static std::unique_ptr<RateCounter> Create(int windowSize, StopWatchMode mode)
    {
      return std::make_unique<RateCounter>(windowSize, mode);
    }
 
 
    RateCounter()
      : stopWatch_(Cvb::StopWatchMode::MultiCPU)
    {
    }
 
 
    explicit RateCounter(int windowSize)
      : stopWatch_(Cvb::StopWatchMode::MultiCPU)
      , windowSize_(windowSize)
    {
 
    }
 
 
    RateCounter(int windowSize, StopWatchMode mode)
      : stopWatch_(mode)
      , windowSize_(windowSize)
    {
 
    }
 
    RateCounter(const RateCounter& other) = delete;
    RateCounter& operator=(const RateCounter & other) = delete;
    RateCounter(RateCounter&& other) = default; // moving std::deque may throw
    RateCounter& operator=(RateCounter&& other) = default; // moving std::deque may throw
    ~RateCounter() = default;
 
 
 
 
 
    StopWatchMode Mode() const noexcept
    {
      return stopWatch_.Mode();
    }
 
 
    int WindowSize() const noexcept
    {
      return windowSize_;
    }
 
 
 
    void SetWindowSize(int windowSize)
    {
      if (windowSize_ == windowSize)
        return;
 
      if (windowSize < MinimumWindowSize || windowSize > MaximumWindowSize)
        throw std::out_of_range("Window size out of range.");
 
      windowSize_ = windowSize;
 
      while (static_cast<int>(measurements_.size()) > windowSize_)
        measurements_.pop_front();
    }
 
 
 
 
 
    std::chrono::milliseconds AverageTimeSpan() const noexcept
    {
      double sum = std::accumulate(measurements_.begin(), measurements_.end(), 0.0);
      if (!measurements_.size())
        return std::chrono::milliseconds::zero();
 
      auto result = std::round(sum / static_cast<double>(measurements_.size()));
      return std::chrono::milliseconds(static_cast<std::chrono::milliseconds::rep>(result));
    }
 
 
 
    double Rate() const noexcept
    {
      if (measurements_.size() < 2)
        return std::numeric_limits<double>::quiet_NaN();
 
      auto averageTimeSpan = AverageTimeSpan();
      return 1000.0 / static_cast<double>(averageTimeSpan.count());
    }
 
 
 
    int NumSteps() const noexcept
    {
      return numSteps_;
    }
 
 
    void Reset() noexcept
    {
      measurements_.clear();
      lastReading_ = std::numeric_limits<double>::quiet_NaN();
      numSteps_ = 0;
    }
 
 
    void Step() noexcept
    {
      if (std::isnan(lastReading_))
      {
        lastReading_ = 0.0;
        stopWatch_.Start();
      }
      else
      {
        auto now = static_cast<double>(stopWatch_.TimeSpan().count());
        measurements_.push_back(now - lastReading_);
        lastReading_ = now;
        ++numSteps_;
 
        while (static_cast<int>(measurements_.size()) > windowSize_)
          measurements_.pop_front();
      }
    }
 
 
 
 
 
 
  private:
 
    StopWatch stopWatch_;
 
    int windowSize_ = DefaultWindowSize;
 
    std::deque<double> measurements_;
 
    double lastReading_ = std::numeric_limits<double>::quiet_NaN();
 
    int numSteps_ = 0;
};
 
 
}
 
 
CVB_END_INLINE_NS
 
}