frequencyEstimator.hpp

Go to the documentation of this file.

#ifndef RTCTK_COMPONENTFRAMEWORK_FREQUENCYESTIMATOR_HPP
#define RTCTK_COMPONENTFRAMEWORK_FREQUENCYESTIMATOR_HPP
 
#include <rtctk/componentFramework/componentMetricsIf.hpp>
#include <rtctk/componentFramework/logger.hpp>
 
#include <chrono>
#include <string>
 
namespace rtctk::componentFramework {

template <typename ClockType = std::chrono::steady_clock>
class FrequencyEstimator {
public:
    FrequencyEstimator(ComponentMetricsIf& metrics,
                       const std::string& desc,
                       const std::string& prefix = "")
        : m_start_time(ClockType::now()), m_frequency_estimate(0) {
        std::string path;
        if (prefix == "") {
            path = "frequency_estimate";
        } else {
            path = prefix + "/frequency_estimate";
        }
 
        const InfluxTagMap base_tags = {
            {"prefix", prefix}
        };
 
        try {
            m_frequency_estimate_reg =
                metrics.AddCounter(&m_frequency_estimate, CounterMetricInfo(
                    path,
                    desc + " [Hz]",
                    base_tags,
                    "frequency_estimate",
                    Unit::HERTZ
                )
            );
        } catch (...) {
            LOG4CPLUS_ERROR(GetLogger("rtctk"),
                            "FrequencyEstimator: Failed to register to metrics service. "
                            "Will ignore and continue anyway: "
                                << NestedExceptionPrinter(std::current_exception()));
        }
    }

    inline void Tick() noexcept {
        using namespace std::chrono_literals;
 
        ++m_num_samples;
        auto now_time = ClockType::now();
        std::chrono::duration<double, std::ratio<1>> elapsed_time = now_time - m_start_time;
        if (elapsed_time > 1s) {
            m_start_time = now_time;
            m_frequency_estimate.Store(m_num_samples / elapsed_time.count());
            m_num_samples = 0;
        }
    }

    double GetValue() const {
        return m_frequency_estimate.Load();
    }

    void Reset() {
        m_frequency_estimate.Store(0);
        m_start_time = ClockType::now();
        m_num_samples = 0;
    }
 
private:
    uint32_t m_num_samples = 0;
    typename ClockType::time_point m_start_time;
 
    perfc::CounterDouble m_frequency_estimate;
    perfc::ScopedRegistration m_frequency_estimate_reg;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_FREQUENCYESTIMATOR_HPP