timer.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2025, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <algorithm> // for max
#include <atomic>    // for atomic, __atomic_base, memory_order_relaxed
#include <cassert>   // for assert
#include <chrono>    // for duration, time_point, operator-, operator<=>, steady_clock
#include <compare>   // for operator>=, strong_ordering
#include <concepts>  // for same_as
#include <cstdint>   // for uint64_t
 
#include <hibf/platform.hpp>
 
namespace seqan::hibf
{
 
class concurrent_timer;
 
class serial_timer
{
private:
    using steady_clock_t = std::chrono::steady_clock;
 
    steady_clock_t::time_point start_point{std::chrono::time_point<steady_clock_t>::max()};
    steady_clock_t::time_point stop_point{};
 
    steady_clock_t::rep ticks{};
    steady_clock_t::rep max{};
    uint64_t count{};
 
    friend class concurrent_timer;
 
public:
    serial_timer() = default;                                 
    serial_timer(serial_timer const &) = default;             
    serial_timer & operator=(serial_timer const &) = default; 
    serial_timer(serial_timer &&) = default;                  
    serial_timer & operator=(serial_timer &&) = default;      
    ~serial_timer() = default;                                
 
 
    void start()
    {
        start_point = steady_clock_t::now();
    }
    void start() {…}
 
    void stop()
    {
        stop_point = steady_clock_t::now();
        assert(stop_point >= start_point);
        steady_clock_t::rep duration = (stop_point - start_point).count();
 
        ticks += duration;
        max = std::max(max, duration);
        ++count;
    }
    void stop() {…}
 
    template <typename timer_t>
        requires (std::same_as<timer_t, serial_timer> || std::same_as<timer_t, concurrent_timer>)
    void operator+=(timer_t const & other)
    {
        steady_clock_t::rep ticks_to_add{};
        if constexpr (std::same_as<timer_t, concurrent_timer>)
            ticks_to_add = other.ticks.load();
        else
            ticks_to_add = other.ticks;
 
        ticks += ticks_to_add;
        max = std::max(max, ticks_to_add);
        ++count;
    }
    void operator+=(timer_t const & other) {…}
 
    double in_seconds() const
    {
        return std::chrono::duration<double>(steady_clock_t::duration{ticks}).count();
    }
    double in_seconds() const {…}
 
    double max_in_seconds() const
    {
        return std::chrono::duration<double>(steady_clock_t::duration{max}).count();
    }
    double max_in_seconds() const {…}
 
    double avg_in_seconds() const
    {
        assert(count > 0u);
        return in_seconds() / count;
    }
    double avg_in_seconds() const {…}
 
    constexpr bool operator==(serial_timer const &) const
    {
        return true;
    }
    constexpr bool operator==(serial_timer const &) const {…}
 
    constexpr bool operator==(concurrent_timer const &) const
    {
        return true;
    }
    constexpr bool operator==(concurrent_timer const &) const {…}
};
class serial_timer {…};
 
class concurrent_timer
{
private:
    using steady_clock_t = std::chrono::steady_clock;
 
    alignas(64) std::atomic<steady_clock_t::rep> ticks{};
 
    steady_clock_t::time_point start_point{std::chrono::time_point<steady_clock_t>::max()};
    steady_clock_t::time_point stop_point{};
 
    alignas(64) std::atomic<steady_clock_t::rep> max{};
    alignas(64) std::atomic<uint64_t> count{};
 
    friend class serial_timer;
 
    void update_max(steady_clock_t::rep const value)
    {
        for (steady_clock_t::rep previous_value = max;
             previous_value < value && !max.compare_exchange_weak(previous_value, value, std::memory_order_relaxed);)
            ;
    }
 
public:
    concurrent_timer() = default;
    concurrent_timer(concurrent_timer const & other) :
        ticks{other.ticks.load()},
        start_point{other.start_point},
        stop_point{other.stop_point},
        max{other.max.load()},
        count{other.count.load()}
    {}
    concurrent_timer(concurrent_timer const & other) : {…}
    concurrent_timer & operator=(concurrent_timer const & other)
    {
        ticks = other.ticks.load();
        start_point = other.start_point;
        stop_point = other.stop_point;
        max = other.max.load();
        count = other.count.load();
        return *this;
    }
    concurrent_timer & operator=(concurrent_timer const & other) {…}
    concurrent_timer(concurrent_timer && other) noexcept :
        ticks{other.ticks.load()},
        start_point{other.start_point},
        stop_point{other.stop_point},
        max{other.max.load()},
        count{other.count.load()}
    {}
    concurrent_timer(concurrent_timer && other) noexcept : {…}
    concurrent_timer & operator=(concurrent_timer && other) noexcept
    {
        ticks = other.ticks.load();
        start_point = other.start_point;
        stop_point = other.stop_point;
        max = other.max.load();
        count = other.count.load();
        return *this;
    }
    concurrent_timer & operator=(concurrent_timer && other) noexcept {…}
    ~concurrent_timer() = default;
 
    void start()
    {
        start_point = steady_clock_t::now();
    }
    void start() {…}
 
    void stop()
    {
        stop_point = steady_clock_t::now();
        assert(stop_point >= start_point);
        steady_clock_t::rep duration = (stop_point - start_point).count();
 
        ticks += duration;
        update_max(duration);
        ++count;
    }
    void stop() {…}
 
    template <typename timer_t>
        requires (std::same_as<timer_t, serial_timer> || std::same_as<timer_t, concurrent_timer>)
    void operator+=(timer_t const & other)
    {
        ticks += other.ticks;
        update_max(other.ticks);
        ++count;
    }
    void operator+=(timer_t const & other) {…}
 
    double in_seconds() const
    {
        return std::chrono::duration<double>(steady_clock_t::duration{ticks.load()}).count();
    }
    double in_seconds() const {…}
 
    double max_in_seconds() const
    {
        return std::chrono::duration<double>(steady_clock_t::duration{max.load()}).count();
    }
    double max_in_seconds() const {…}
 
    double avg_in_seconds() const
    {
        assert(count.load() > 0u);
        return in_seconds() / count.load();
    }
    double avg_in_seconds() const {…}
 
    constexpr bool operator==(serial_timer const &) const
    {
        return true;
    }
    constexpr bool operator==(serial_timer const &) const {…}
 
    constexpr bool operator==(concurrent_timer const &) const
    {
        return true;
    }
    constexpr bool operator==(concurrent_timer const &) const {…}
};
class concurrent_timer {…};
 
} // namespace seqan::hibf