rate_counter.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/statistics/rate_counter.hpp
/// @brief @copybrief utils::statistics::RateCounter
 
#include <atomic>
 
#include <userver/utils/statistics/rate.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils::statistics {
 
class Writer;
 
/// @ingroup userver_universal
///
/// @brief Atomic counter of type Rate with relaxed memory ordering by default
///
/// This class is represented as Rate metric when serializing to statistics.
/// Otherwise it is the same class as @ref utils::statistics::RelaxedCounter.
class RateCounter final {
public:
    using ValueType = Rate;
 
    constexpr RateCounter() noexcept = default;
 
    constexpr explicit RateCounter(Rate desired) noexcept : val_(desired.value) {}
 
    constexpr explicit RateCounter(Rate::ValueType desired) noexcept : val_(desired) {}
 
    RateCounter(const RateCounter& other) noexcept : val_(other.Load().value) {}
 
    RateCounter& operator=(const RateCounter& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Store(other.Load());
        return *this;
    }
 
    RateCounter& operator=(Rate desired) noexcept {
        Store(desired);
        return *this;
    }
 
    void Store(Rate desired, std::memory_order order = std::memory_order_relaxed) noexcept {
        val_.store(desired.value, order);
    }
 
    Rate Load() const noexcept { return Rate{val_.load(std::memory_order_relaxed)}; }
 
    void Add(Rate arg, std::memory_order order = std::memory_order_relaxed) noexcept {
        val_.fetch_add(arg.value, order);
    }
 
    void AddAsSingleProducer(Rate arg) noexcept {
        val_.store(val_.load(std::memory_order_relaxed) + arg.value, std::memory_order_relaxed);
    }
 
    void Increment() noexcept { val_.fetch_add(1, std::memory_order_relaxed); }
 
    Rate operator++() noexcept { return Rate{val_.fetch_add(1, std::memory_order_relaxed) + 1}; }
 
    Rate operator++(int) noexcept { return Rate{val_.fetch_add(1, std::memory_order_relaxed)}; }
 
    Rate operator+=(Rate arg) noexcept {
        return Rate{val_.fetch_add(arg.value, std::memory_order_relaxed) + arg.value};
    }
 
    Rate operator+=(const RateCounter& arg) noexcept { return *this += arg.Load(); }
 
private:
    static_assert(std::atomic<Rate::ValueType>::is_always_lock_free);
 
    std::atomic<Rate::ValueType> val_{0};
};
 
void DumpMetric(Writer& writer, const RateCounter& value);
 
void ResetMetric(RateCounter& value);
 
}  // namespace utils::statistics
 
USERVER_NAMESPACE_END