sliding_window_counter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <memory>
#include <vector>
 
namespace kcenon::thread::metrics {
 
class SlidingWindowCounter {
public:
    static constexpr std::size_t DEFAULT_BUCKETS_PER_SECOND = 10;
 
    explicit SlidingWindowCounter(
        std::chrono::seconds window_size,
        std::size_t buckets_per_second = DEFAULT_BUCKETS_PER_SECOND);
 
    SlidingWindowCounter(const SlidingWindowCounter& other);
 
    SlidingWindowCounter(SlidingWindowCounter&& other) noexcept;
 
    SlidingWindowCounter& operator=(const SlidingWindowCounter& other);
 
    SlidingWindowCounter& operator=(SlidingWindowCounter&& other) noexcept;
 
    ~SlidingWindowCounter() = default;
 
    void increment(std::size_t count = 1);
 
    [[nodiscard]] double rate_per_second() const;
 
    [[nodiscard]] std::uint64_t total_in_window() const;
 
    [[nodiscard]] std::uint64_t all_time_total() const;
 
    void reset();
 
    [[nodiscard]] std::chrono::seconds window_size() const;
 
    [[nodiscard]] std::size_t bucket_count() const;
 
private:
    struct Bucket {
        std::atomic<std::uint64_t> count{0};
        std::atomic<std::uint64_t> timestamp_ms{0};  // Bucket start time
 
        Bucket() = default;
 
        Bucket(const Bucket& other)
            : count(other.count.load(std::memory_order_relaxed)),
              timestamp_ms(other.timestamp_ms.load(std::memory_order_relaxed)) {}
 
        Bucket(Bucket&& other) noexcept
            : count(other.count.load(std::memory_order_relaxed)),
              timestamp_ms(other.timestamp_ms.load(std::memory_order_relaxed)) {}
 
        Bucket& operator=(const Bucket& other) {
            if (this != &other) {
                count.store(other.count.load(std::memory_order_relaxed),
                            std::memory_order_relaxed);
                timestamp_ms.store(other.timestamp_ms.load(std::memory_order_relaxed),
                                   std::memory_order_relaxed);
            }
            return *this;
        }
 
        Bucket& operator=(Bucket&& other) noexcept {
            if (this != &other) {
                count.store(other.count.load(std::memory_order_relaxed),
                            std::memory_order_relaxed);
                timestamp_ms.store(other.timestamp_ms.load(std::memory_order_relaxed),
                                   std::memory_order_relaxed);
            }
            return *this;
        }
    };
 
    std::chrono::seconds window_size_;
 
    std::chrono::milliseconds bucket_duration_;
 
    std::vector<Bucket> buckets_;
 
    std::atomic<std::uint64_t> all_time_total_{0};
 
    [[nodiscard]] std::size_t current_bucket_index() const;
 
    [[nodiscard]] std::size_t bucket_index_for_time(std::uint64_t timestamp_ms) const;
 
    [[nodiscard]] static std::uint64_t current_time_ms();
 
    [[nodiscard]] bool is_bucket_valid(
        std::uint64_t bucket_timestamp_ms,
        std::uint64_t current_ms) const;
 
    void advance_bucket(std::size_t bucket_index, std::uint64_t current_ms);
};
 
} // namespace kcenon::thread::metrics