Timing.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <chrono>
#include <cstdint>
#include <stdexcept>
#include <string>
 
namespace ecs
{
    static_assert(sizeof(std::chrono::microseconds::rep) >= 8, "intervals need a 64-bit microsecond count");
 
    constexpr std::chrono::microseconds MAX_INTERVAL = std::chrono::hours(24 * 36525);
 
    constexpr std::chrono::microseconds DEFAULT_INTERVAL{1000000 / 30};
 
    constexpr uint32_t MAX_CATCHUP = 2;
 
    class Timing
    {
      public:
        Timing(std::chrono::microseconds interval = DEFAULT_INTERVAL)
          : updateInterval(Timing::checked(interval)),
            lastUpdateTime(Timing::steadyNow())
        {
        }
 
        [[deprecated("use Timing(std::chrono::microseconds) instead")]]
        Timing(uint32_t frequency)
          : updateInterval(static_cast<int64_t>(frequency)),
            lastUpdateTime(Timing::steadyNow())
        {
        }
 
        bool ShouldUpdate(std::chrono::microseconds now)
        {
            if(this->updateInterval == 0)
                return true;
 
            int64_t current_time = now.count();
            int64_t elapsed = current_time - this->lastUpdateTime;
            if(elapsed < 0)
                elapsed = 0;
 
            if(elapsed >= this->updateInterval)
            {
                // Remainder-carry: advance by the largest multiple of the interval that fits, so the
                // average rate is exact and drift-free under jittered sampling.
                int64_t intervals = elapsed / this->updateInterval;
 
                // MAX_CATCHUP clamp: if stalled for too long, snap forward instead of catching up
                // (prevents a burst after suspend or a long pause).
                if(intervals > static_cast<int64_t>(MAX_CATCHUP))
                    this->lastUpdateTime = current_time;
                else
                    this->lastUpdateTime += intervals * this->updateInterval;
 
                return true;
            }
            return false;
        }
 
        bool ShouldUpdate()
        {
            return this->ShouldUpdate(std::chrono::microseconds(Timing::steadyNow()));
        }
 
        void Restart(std::chrono::microseconds now)
        {
            this->lastUpdateTime = now.count();
        }
 
        void SetInterval(std::chrono::microseconds interval)
        {
            this->updateInterval = Timing::checked(interval);
        }
 
        std::chrono::microseconds GetInterval() const
        {
            return std::chrono::microseconds(this->updateInterval);
        }
 
        [[deprecated("use SetInterval(std::chrono::microseconds) instead")]]
        void SetFrequency(uint32_t frequency)
        {
            this->updateInterval = static_cast<int64_t>(frequency);
        }
 
        [[deprecated("use GetInterval() instead")]]
        uint32_t GetFrequency() const
        {
            return static_cast<uint32_t>(std::min<int64_t>(this->updateInterval, UINT32_MAX));
        }
 
      private:
        int64_t updateInterval;
        int64_t lastUpdateTime;
 
        static int64_t checked(std::chrono::microseconds interval)
        {
            if(interval.count() < 0 || interval > MAX_INTERVAL)
            {
                throw std::runtime_error("ecs::Timing: interval " + std::to_string(interval.count()) +
                                         " us is outside 0 to " + std::to_string(MAX_INTERVAL.count()) + " us.");
            }
            return interval.count();
        }
 
        static int64_t steadyNow()
        {
            using namespace std::chrono;
            return duration_cast<microseconds>(steady_clock::now().time_since_epoch()).count();
        }
    };
}