stopwatch.h

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: 2025 Nessan Fitzmaurice <nzznfitz+gh@icloud.com>
// SPDX-License-Identifier: MIT

 
#include <atomic>
#include <cassert>
#include <chrono>
#include <iostream>
#include <string>
#include <format>
 
namespace utilities {
template<typename Clock = std::chrono::high_resolution_clock>
class stopwatch {
public:
    using clock_type = Clock;

    explicit stopwatch(const std::string& str = "") : m_name(str) { reset(); }

    std::string name() const { return m_name; }

    std::string& name() { return m_name; }

    void reset()
    {
        m_zero = clock_type::now();
        m_split = 0;
        m_prior = 0;
    }

    double elapsed() const
    {
        std::atomic_thread_fence(std::memory_order_relaxed);
        auto t = clock_type::now();
        std::atomic_thread_fence(std::memory_order_relaxed);
        return std::chrono::duration<double>(t - m_zero).count();
    }

    double click()
    {
        auto tau = elapsed();
        m_prior = m_split;
        m_split = tau;
        return m_split;
    }

    double split() const { return m_split; }

    double lap() const { return m_split - m_prior; }

    constexpr static std::string format_seconds(double seconds)
    {
        if (seconds < 1.0) { return std::format("{:.2f}ms", seconds * 1000.0); }
        return std::format("{:.2f}s", seconds);
    }

    std::string to_string() const
    {
        auto tau = format_seconds(elapsed());
        if (m_name.empty()) return tau;
        return std::format("{}: {}", m_name, tau);
    }
 
private:
    using time_point = typename Clock::time_point;
 
    std::string m_name;  // Name of the stopwatch.
    time_point  m_zero;  // The stopwatch measures time (in seconds) from this time point.
    double      m_split; // The total seconds to when the stopwatch was most recently clicked.
    double      m_prior; // The prior split.
};

template<class Rep, class Period>
inline double
to_seconds(const std::chrono::duration<Rep, Period>& d)
{
    return std::chrono::duration<double>(d).count();
}

using precise_stopwatch = stopwatch<std::chrono::high_resolution_clock>;

using steady_stopwatch = stopwatch<std::chrono::steady_clock>;

using system_stopwatch = stopwatch<std::chrono::system_clock>;

template<typename Clock>
inline std::ostream&
operator<<(std::ostream& os, const stopwatch<Clock>& rhs)
{
    return os << rhs.to_string();
}
 
} // namespace utilities
 
// --------------------------------------------------------------------------------------------------------------------
// Specialises `std::formatter` to handle our stopwatch class ...
// -------------------------------------------------------------------------------------------------------------------

template<typename Clock>
struct std::formatter<utilities::stopwatch<Clock>> {
 
    constexpr auto parse(const std::format_parse_context& ctx)
    {
        // Throw an error for anything that is not default formatted for now ...
        auto it = ctx.begin();
        assert(it == ctx.end() || *it == '}');
        return it;
    }
 
    template<class FormatContext>
    auto format(const utilities::stopwatch<Clock>& rhs, FormatContext& ctx) const
    {
        // Punt the formatting to the stopwatch's `to_string()` method.
        return std::format_to(ctx.out(), "{}", rhs.to_string());
    }
};