throttle.h

Go to the documentation of this file.

#ifndef __thottle_h__
#define __thottle_h__
#include <Options.h>
#include <chrono>
#include <mutex>
#include <thread>
 
namespace throttle {
    typedef std::chrono::system_clock clock_type ;
    static auto start = clock_type::now();
    class watch {
        options::single<double> desiredRate;
        options::single<double> tau;
        options::single<double> p;
        options::single<double> i;
        double rateIntegral;
        double lastRate;
        clock_type::time_point lastStop;
        std::mutex updateMutex;
      public:
        watch(const std::string& name):
            desiredRate('\0', name + "-rate", "throttle rate for " + name, 0),
            tau('\0', name + "-tau", "time constant for " + name, 1),
            p('\0', name + "-p", "prop constant for " + name, 1),
            i('\0', name + "-i", "integral constant for " + name, 1),
            lastStop(clock_type::now()) {
        }
        void update(double units = 1.0) {
            if (desiredRate == 0) {
                return;
            }
            std::unique_lock<decltype(updateMutex)> lock(updateMutex);
            auto now = clock_type::now();
            auto dt = std::chrono::duration_cast<std::chrono::duration<double>>(now - lastStop).count();
            auto factor = dt / tau;
            if (factor > 1) {
                factor = 1;
            }
            lastRate = units / dt * factor + (1 - factor) * lastRate;
            rateIntegral += (lastRate - desiredRate) * dt;
            lastStop = now;
        }
        void wait() {
            if (desiredRate == 0) {
                return;
            }
            auto dRate = (lastRate - desiredRate) * p + rateIntegral * i;
            if (dRate <= 0) {
                return;
            }
            auto w = dRate / desiredRate;
            if (w > 1) {
                w = 1;
            }
            std::this_thread::sleep_for(std::chrono::duration<double>(w));
        }
        template <typename T, class ... Types> T action(T (*f)(Types...), Types ... args) {
            wait();
            auto result = f(args ...);
            update();
            return result;
        }
    };
    class action {
        watch& lWatch;
        double units;
      public:
        action(watch& aWatch, double aUnits = 1.0):
            lWatch(aWatch),
            units(aUnits) {
            lWatch.wait();
        }
        ~action() {
            lWatch.update(units);
        }
    };
 
} // end namespace throttle
#endif