CpuTickTimer.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
#ifndef _TIME_SHIELD_CPU_TICK_TIMER_HPP_INCLUDED
#define _TIME_SHIELD_CPU_TICK_TIMER_HPP_INCLUDED

 
#include "time_utils.hpp"
 
#include <cstddef>
#include <limits>
 
namespace time_shield {

    class CpuTickTimer {
    public:
        explicit CpuTickTimer(bool is_start_immediately = true) noexcept {
            if (is_start_immediately) {
                start();
            }
        }

        void start() noexcept {
            m_start_ticks = get_cpu_time();
            m_end_ticks = m_start_ticks;
            m_is_running = true;
        }

        void restart() noexcept {
            reset_samples();
            start();
        }

        void stop() noexcept {
            if (m_is_running) {
                m_end_ticks = get_cpu_time();
                m_is_running = false;
            }
        }

        [[nodiscard]] double elapsed() const noexcept {
            const double final_ticks = m_is_running ? get_cpu_time() : m_end_ticks;
            return final_ticks - m_start_ticks;
        }

        double record_sample() noexcept {
            if (!m_is_running) {
                start();
                m_last_sample_ticks = 0.0;
                return 0.0;
            }
 
            const double now_ticks = get_cpu_time();
            m_last_sample_ticks = now_ticks - m_start_ticks;
            m_start_ticks = now_ticks;
 
            accumulate_ticks(m_last_sample_ticks);
            ++m_sample_count;
 
            return m_last_sample_ticks;
        }

        void reset_samples() noexcept {
            m_total_ticks = 0.0;
            m_total_compensation = 0.0;
            m_last_sample_ticks = 0.0;
            m_sample_count = 0;
        }

        [[nodiscard]] std::size_t sample_count() const noexcept {
            return m_sample_count;
        }

        [[nodiscard]] double total_ticks() const noexcept {
            return m_total_ticks;
        }

        [[nodiscard]] double average_ticks() const noexcept {
            if (m_sample_count == 0U) {
                return std::numeric_limits<double>::quiet_NaN();
            }
            return m_total_ticks / static_cast<double>(m_sample_count);
        }

        [[nodiscard]] double last_sample_ticks() const noexcept {
            return m_last_sample_ticks;
        }
 
    private:
        void accumulate_ticks(double sample_ticks) noexcept {
            const double compensated = sample_ticks - m_total_compensation;
            const double updated_total = m_total_ticks + compensated;
            m_total_compensation = (updated_total - m_total_ticks) - compensated;
            m_total_ticks = updated_total;
        }
 
        double m_start_ticks { 0.0 };
        double m_end_ticks { 0.0 };
        double m_total_ticks { 0.0 };
        double m_total_compensation { 0.0 };
        double m_last_sample_ticks { 0.0 };
        std::size_t m_sample_count { 0 };
        bool m_is_running { false };
    };
 
} // namespace time_shield
 
#endif // _TIME_SHIELD_CPU_TICK_TIMER_HPP_INCLUDED