bufferMonitor.hpp

Go to the documentation of this file.

#ifndef RTCTK_COMPONENTFRAMEWORK_BUFFERMONITOR_HPP
#define RTCTK_COMPONENTFRAMEWORK_BUFFERMONITOR_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 BufferMonitor {
public:
    BufferMonitor(ComponentMetricsIf& metrics,
                  const std::string& desc,
                  const std::string& prefix = "")
        : m_start_time(ClockType::now()), m_accumulator{} {
        std::string path;
        if (prefix == "") {
            path = "buffer_occupancy";
        } else {
            path = prefix + "/buffer_occupancy";
        }
 
        const InfluxTagMap base_tags = {{"prefix", prefix}};
 
        m_pc_occupancy_min_reg =
            metrics.AddCounter(&m_pc_occupancy_min,
                               CounterMetricInfo(path + "/min",
                                                 desc + ", min [%]",
                                                 base_tags.Extend({"aggregation", "min"}),
                                                 "buffer_occupancy",
                                                 Unit::PERCENT));
 
        m_pc_occupancy_mean_reg =
            metrics.AddCounter(&m_pc_occupancy_mean,
                               CounterMetricInfo(path + "/mean",
                                                 desc + ", mean [%]",
                                                 base_tags.Extend({"aggregation", "mean"}),
                                                 "buffer_occupancy",
                                                 Unit::PERCENT));
 
        m_pc_occupancy_max_reg =
            metrics.AddCounter(&m_pc_occupancy_max,
                               CounterMetricInfo(path + "/max",
                                                 desc + ", max [%]",
                                                 base_tags.Extend({"aggregation", "max"}),
                                                 "buffer_occupancy",
                                                 Unit::PERCENT));
 
        m_pc_occupancy_global_max_reg =
            metrics.AddCounter(&m_pc_occupancy_global_max,
                               CounterMetricInfo(path + "/global_max",
                                                 desc + ", global max [%]",
                                                 base_tags.Extend({"aggregation", "global_max"}),
                                                 "buffer_occupancy",
                                                 Unit::PERCENT));
    }

    inline void Tick(size_t elements, size_t capacity) noexcept {
        using namespace std::chrono_literals;
 
        auto now_time = ClockType::now();
        auto elapsed_time = now_time - m_start_time;
        if (elapsed_time > 10s and ba::count(m_accumulator) > 0) {
            m_start_time = now_time;
 
            m_pc_occupancy_min.Store(ba::min(m_accumulator));
            m_pc_occupancy_max.Store(ba::max(m_accumulator));
            m_pc_occupancy_mean.Store(ba::mean(m_accumulator));
            m_pc_occupancy_global_max.Store(
                std::max(m_pc_occupancy_max.Load(), m_pc_occupancy_global_max.Load()));
 
            m_accumulator = {};
        }
 
        size_t occupancy = 100.0 * static_cast<double>(elements) / capacity;
        m_accumulator(occupancy);
    }
 
    struct Result {
        size_t min;         // [%]
        size_t mean;        // [%]
        size_t max;         // [%]
        size_t global_max;  // [%]
    };

    Result GetValue() const {
        Result res;
        res.min = m_pc_occupancy_min.Load();
        res.mean = m_pc_occupancy_mean.Load();
        res.max = m_pc_occupancy_max.Load();
        res.global_max = m_pc_occupancy_global_max.Load();
        return res;
    }

    void Reset() {
        m_accumulator = {};
        m_pc_occupancy_min.Store(0);
        m_pc_occupancy_mean.Store(0);
        m_pc_occupancy_max.Store(0);
        m_pc_occupancy_global_max.Store(0);
    }
 
private:
    typename ClockType::time_point m_start_time;
 
    ba::accumulator_set<double,
                        ba::stats<ba::tag::mean, ba::tag::min, ba::tag::max, ba::tag::count>>
        m_accumulator;
 
    perfc::CounterDouble m_pc_occupancy_min;
    perfc::ScopedRegistration m_pc_occupancy_min_reg;
 
    perfc::CounterDouble m_pc_occupancy_max;
    perfc::ScopedRegistration m_pc_occupancy_max_reg;
 
    perfc::CounterDouble m_pc_occupancy_global_max;
    perfc::ScopedRegistration m_pc_occupancy_global_max_reg;
 
    perfc::CounterDouble m_pc_occupancy_mean;
    perfc::ScopedRegistration m_pc_occupancy_mean_reg;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_BUFFERMONITOR_HPP