durationMonitor.hpp

Go to the documentation of this file.

#ifndef RTCTK_COMPONENTFRAMEWORK_DURATIONMONITOR_HPP
#define RTCTK_COMPONENTFRAMEWORK_DURATIONMONITOR_HPP
 
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/count.hpp>
#include <boost/accumulators/statistics/max.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <rtctk/componentFramework/componentMetricsIf.hpp>
 
#include <chrono>
#include <string>
 
namespace rtctk::componentFramework {
namespace ba = boost::accumulators;

template <typename ClockType = std::chrono::steady_clock>
class DurationMonitor {
public:
    DurationMonitor(ComponentMetricsIf& metrics,
                    const std::string& desc,
                    const std::string& prefix = "")
        : m_start_time(ClockType::now()) {
        std::string path;
        if (prefix == "") {
            path = "duration_estimate";
        } else {
            path = prefix + "/duration_estimate";
        }
 
        const InfluxTagMap base_tags = {{"prefix", prefix}};
 
        m_pc_duration_min_reg =
            metrics.AddCounter(&m_pc_duration_min,
                               CounterMetricInfo(path + "/min",
                                                 desc + ", min [us]",
                                                 base_tags.Extend({"aggregation", "min"}),
                                                 "duration_estimate",
                                                 Unit::MICRO_SECONDS));
 
        m_pc_duration_mean_reg =
            metrics.AddCounter(&m_pc_duration_mean,
                               CounterMetricInfo(path + "/mean",
                                                 desc + ", mean [us]",
                                                 base_tags.Extend({"aggregation", "mean"}),
                                                 "duration_estimate",
                                                 Unit::MICRO_SECONDS));
 
        m_pc_duration_max_reg =
            metrics.AddCounter(&m_pc_duration_max,
                               CounterMetricInfo(path + "/max",
                                                 desc + ", max [us]",
                                                 base_tags.Extend({"aggregation", "max"}),
                                                 "duration_estimate",
                                                 Unit::MICRO_SECONDS));
    }

    inline void Tick(std::chrono::duration<double, std::micro> elapsed) noexcept {
        using namespace std::chrono_literals;
 
        auto now_time = ClockType::now();
        typename ClockType::duration elapsed_time = now_time - m_start_time;
        if (elapsed_time > 10s and ba::count(m_accumulator) > 0) {
            m_start_time = now_time;
 
            m_pc_duration_min.Store(ba::min(m_accumulator));
            m_pc_duration_max.Store(ba::max(m_accumulator));
            m_pc_duration_mean.Store(ba::mean(m_accumulator));
 
            m_accumulator = {};
        }
 
        m_accumulator(elapsed.count());
    }
 
    struct Result {
        int64_t min;   // [us]
        int64_t mean;  // [us]
        int64_t max;   // [us]
    };

    Result GetValue() const {
        Result res;
        res.min = m_pc_duration_min.Load();
        res.mean = m_pc_duration_mean.Load();
        res.max = m_pc_duration_max.Load();
        return res;
    }

    void Reset() {
        m_accumulator = {};
        m_pc_duration_min.Store(0);
        m_pc_duration_mean.Store(0);
        m_pc_duration_max.Store(0);
    }
 
private:
    ba::accumulator_set<double,
                        ba::stats<ba::tag::mean, ba::tag::min, ba::tag::max, ba::tag::count>>
        m_accumulator;
 
    typename ClockType::time_point m_start_time;
 
    perfc::CounterI64 m_pc_duration_min;
    perfc::ScopedRegistration m_pc_duration_min_reg;
 
    perfc::CounterI64 m_pc_duration_max;
    perfc::ScopedRegistration m_pc_duration_max_reg;
 
    perfc::CounterI64 m_pc_duration_mean;
    perfc::ScopedRegistration m_pc_duration_mean_reg;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_DURATIONMONITOR_HPP