latency_histogram.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 <array>
#include <atomic>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <limits>
 
namespace kcenon::thread::metrics {
 
class LatencyHistogram {
public:
    static constexpr std::size_t BUCKET_COUNT = 64;
 
    LatencyHistogram();
 
    LatencyHistogram(const LatencyHistogram& other);
 
    LatencyHistogram(LatencyHistogram&& other) noexcept;
 
    LatencyHistogram& operator=(const LatencyHistogram& other);
 
    LatencyHistogram& operator=(LatencyHistogram&& other) noexcept;
 
    ~LatencyHistogram() = default;
 
    void record(std::chrono::nanoseconds value);
 
    void record_ns(std::uint64_t nanoseconds);
 
    [[nodiscard]] double percentile(double p) const;
 
    [[nodiscard]] double p50() const { return percentile(0.50); }
 
    [[nodiscard]] double p90() const { return percentile(0.90); }
 
    [[nodiscard]] double p95() const { return percentile(0.95); }
 
    [[nodiscard]] double p99() const { return percentile(0.99); }
 
    [[nodiscard]] double p999() const { return percentile(0.999); }
 
    [[nodiscard]] double mean() const;
 
    [[nodiscard]] double stddev() const;
 
    [[nodiscard]] std::uint64_t min() const;
 
    [[nodiscard]] std::uint64_t max() const;
 
    [[nodiscard]] std::uint64_t count() const;
 
    [[nodiscard]] std::uint64_t sum() const;
 
    void reset();
 
    [[nodiscard]] bool empty() const;
 
    void merge(const LatencyHistogram& other);
 
    [[nodiscard]] std::uint64_t bucket_count(std::size_t bucket_index) const;
 
    [[nodiscard]] static std::uint64_t bucket_lower_bound(std::size_t bucket_index);
 
    [[nodiscard]] static std::uint64_t bucket_upper_bound(std::size_t bucket_index);
 
private:
    std::array<std::atomic<std::uint64_t>, BUCKET_COUNT> buckets_;
 
    std::atomic<std::uint64_t> total_count_{0};
 
    std::atomic<std::uint64_t> total_sum_{0};
 
    std::atomic<std::uint64_t> min_value_{std::numeric_limits<std::uint64_t>::max()};
 
    std::atomic<std::uint64_t> max_value_{0};
 
    [[nodiscard]] static std::size_t compute_bucket_index(std::uint64_t value);
 
    [[nodiscard]] static double bucket_midpoint(std::size_t bucket_index);
};
 
} // namespace kcenon::thread::metrics