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 <chrono>
#include <iostream>
 
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; }

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

    constexpr 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();
    }

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

    constexpr double split() const { return m_split; }

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

    std::string to_string() const
    {
        auto tau = elapsed();
        if (m_name.empty()) return std::format("{}s", tau);
        return std::format("{}: {}s", 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<typename Clock>
inline std::ostream&
operator<<(std::ostream& os, const stopwatch<Clock>& rhs)
{
    return os << rhs.to_string();
}

template<class Rep, class Period>
constexpr 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>;
 
} // namespace utilities