work_stealing_stats.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 <cstdint>
 
namespace kcenon::thread
{
 
struct work_stealing_stats_snapshot
{
    std::uint64_t steal_attempts{0};
    std::uint64_t successful_steals{0};
    std::uint64_t failed_steals{0};
    std::uint64_t jobs_stolen{0};
    std::uint64_t same_node_steals{0};
    std::uint64_t cross_node_steals{0};
    std::uint64_t batch_steals{0};
    std::uint64_t total_batch_size{0};
    std::uint64_t total_steal_time_ns{0};
    std::uint64_t total_backoff_time_ns{0};
 
    [[nodiscard]] auto steal_success_rate() const -> double
    {
        if (steal_attempts == 0)
        {
            return 0.0;
        }
        return static_cast<double>(successful_steals) / static_cast<double>(steal_attempts);
    }
 
    [[nodiscard]] auto avg_batch_size() const -> double
    {
        if (batch_steals == 0)
        {
            return 0.0;
        }
        return static_cast<double>(total_batch_size) / static_cast<double>(batch_steals);
    }
 
    [[nodiscard]] auto cross_node_ratio() const -> double
    {
        auto total = same_node_steals + cross_node_steals;
        if (total == 0)
        {
            return 0.0;
        }
        return static_cast<double>(cross_node_steals) / static_cast<double>(total);
    }
 
    [[nodiscard]] auto avg_steal_time_ns() const -> double
    {
        if (steal_attempts == 0)
        {
            return 0.0;
        }
        return static_cast<double>(total_steal_time_ns) / static_cast<double>(steal_attempts);
    }
};
 
struct work_stealing_stats
{
    // ========================================================================
    // Steal Counts
    // ========================================================================
 
    std::atomic<std::uint64_t> steal_attempts{0};
 
    std::atomic<std::uint64_t> successful_steals{0};
 
    std::atomic<std::uint64_t> failed_steals{0};
 
    std::atomic<std::uint64_t> jobs_stolen{0};
 
    // ========================================================================
    // NUMA Statistics
    // ========================================================================
 
    std::atomic<std::uint64_t> same_node_steals{0};
 
    std::atomic<std::uint64_t> cross_node_steals{0};
 
    // ========================================================================
    // Batch Statistics
    // ========================================================================
 
    std::atomic<std::uint64_t> batch_steals{0};
 
    std::atomic<std::uint64_t> total_batch_size{0};
 
    // ========================================================================
    // Timing Statistics
    // ========================================================================
 
    std::atomic<std::uint64_t> total_steal_time_ns{0};
 
    std::atomic<std::uint64_t> total_backoff_time_ns{0};
 
    // ========================================================================
    // Computed Metrics
    // ========================================================================
 
    [[nodiscard]] auto steal_success_rate() const -> double
    {
        auto attempts = steal_attempts.load(std::memory_order_relaxed);
        if (attempts == 0)
        {
            return 0.0;
        }
        auto successes = successful_steals.load(std::memory_order_relaxed);
        return static_cast<double>(successes) / static_cast<double>(attempts);
    }
 
    [[nodiscard]] auto avg_batch_size() const -> double
    {
        auto batches = batch_steals.load(std::memory_order_relaxed);
        if (batches == 0)
        {
            return 0.0;
        }
        auto total = total_batch_size.load(std::memory_order_relaxed);
        return static_cast<double>(total) / static_cast<double>(batches);
    }
 
    [[nodiscard]] auto cross_node_ratio() const -> double
    {
        auto same = same_node_steals.load(std::memory_order_relaxed);
        auto cross = cross_node_steals.load(std::memory_order_relaxed);
        auto total = same + cross;
        if (total == 0)
        {
            return 0.0;
        }
        return static_cast<double>(cross) / static_cast<double>(total);
    }
 
    [[nodiscard]] auto avg_steal_time_ns() const -> double
    {
        auto attempts = steal_attempts.load(std::memory_order_relaxed);
        if (attempts == 0)
        {
            return 0.0;
        }
        auto total_time = total_steal_time_ns.load(std::memory_order_relaxed);
        return static_cast<double>(total_time) / static_cast<double>(attempts);
    }
 
    void reset()
    {
        steal_attempts.store(0, std::memory_order_relaxed);
        successful_steals.store(0, std::memory_order_relaxed);
        failed_steals.store(0, std::memory_order_relaxed);
        jobs_stolen.store(0, std::memory_order_relaxed);
        same_node_steals.store(0, std::memory_order_relaxed);
        cross_node_steals.store(0, std::memory_order_relaxed);
        batch_steals.store(0, std::memory_order_relaxed);
        total_batch_size.store(0, std::memory_order_relaxed);
        total_steal_time_ns.store(0, std::memory_order_relaxed);
        total_backoff_time_ns.store(0, std::memory_order_relaxed);
    }
 
    [[nodiscard]] auto snapshot() const -> work_stealing_stats_snapshot
    {
        work_stealing_stats_snapshot snap;
        snap.steal_attempts = steal_attempts.load(std::memory_order_acquire);
        snap.successful_steals = successful_steals.load(std::memory_order_acquire);
        snap.failed_steals = failed_steals.load(std::memory_order_acquire);
        snap.jobs_stolen = jobs_stolen.load(std::memory_order_acquire);
        snap.same_node_steals = same_node_steals.load(std::memory_order_acquire);
        snap.cross_node_steals = cross_node_steals.load(std::memory_order_acquire);
        snap.batch_steals = batch_steals.load(std::memory_order_acquire);
        snap.total_batch_size = total_batch_size.load(std::memory_order_acquire);
        snap.total_steal_time_ns = total_steal_time_ns.load(std::memory_order_acquire);
        snap.total_backoff_time_ns = total_backoff_time_ns.load(std::memory_order_acquire);
        return snap;
    }
};
 
} // namespace kcenon::thread