counters.hpp

// Copyright Take Vos 2019-2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "architecture.hpp"
#include "fixed_string.hpp"
#include "time_stamp_count.hpp"
#include "atomic.hpp"
#include "unfair_mutex.hpp"
#include <span>
#include <typeinfo>
#include <typeindex>
#include <string>
#include <atomic>
#include <map>
#include <memory>
#include <mutex>
 
namespace tt {
namespace detail {
 
class counter {
public:
    [[nodiscard]] static counter *get_if(std::string const &name) noexcept
    {
        ttlet lock = std::scoped_lock(_mutex);
        ttlet &map_ = _map.get_or_make();
        ttlet it = map_.find(name);
        if (it == map_.cend()) {
            return nullptr;
        } else {
            tt_axiom(it->second);
            return it->second;
        }
    }
 
    counter(counter const &) = delete;
    counter(counter &&) = delete;
    counter &operator=(counter const &) = delete;
    counter &operator=(counter &&) = delete;
 
    constexpr counter() noexcept
    {
    }
 
    operator uint64_t() const noexcept
    {
        return _total_count.load(std::memory_order::relaxed);
    }
 
    static void log() noexcept
    {
        ttlet lock = std::scoped_lock(_mutex);
        log_header();
        for (ttlet &[string, counter]: _map.get_or_make()) {
            tt_axiom(counter);
            counter->log(string);
        }
    }
 
    static void log_header() noexcept;
 
    void log(std::string const &tag) noexcept;
 
    counter &operator++() noexcept
    {
        _total_count.fetch_add(1, std::memory_order::relaxed);
        return *this;
    }
 
    uint64_t operator++(int) noexcept
    {
        return _total_count.fetch_add(1, std::memory_order::relaxed);
    }
 
    void add_duration(uint64_t duration) noexcept
    {
        _total_count.fetch_add(1, std::memory_order::relaxed);
        fetch_max(_duration_max, duration, std::memory_order::relaxed);
        fetch_min(_duration_min, duration, std::memory_order::relaxed);
 
        // Combine duration with count in a single atomic.
        tt_axiom(duration <= (std::numeric_limits<uint64_t>::max() >> 10));
        duration <<= 16;
        ++duration;
        _duration_avg.fetch_add(duration, std::memory_order::relaxed);
    }
 
protected:
    using map_type = std::map<std::string, counter *>;
 
    constinit static inline unfair_mutex_impl<false> _mutex;
    constinit static inline atomic_unique_ptr<map_type> _map;
 
    std::atomic<uint64_t> _total_count = 0;
    std::atomic<uint64_t> _prev_count = 0;
    std::atomic<uint64_t> _duration_max = 0;
    std::atomic<uint64_t> _duration_min = std::numeric_limits<uint64_t>::max();
 
    std::atomic<uint64_t> _duration_avg = 0;    
};
 
template<basic_fixed_string Tag>
class tagged_counter : public counter {
public:
    tagged_counter() noexcept : counter()
    {
        ttlet lock = std::scoped_lock(_mutex);
        _map.get_or_make()[std::string{Tag}] = this;
    }
};
 
} // namespace detail
 
template<basic_fixed_string Tag>
inline detail::tagged_counter<Tag> global_counter;
 
[[nodiscard]] inline detail::counter *get_global_counter_if(std::string const &name)
{
    return detail::counter::get_if(name);
}
 
} // namespace tt