kcenon::thread::work_stealing_stats Struct Reference

Statistics for work-stealing operations. More...

#include <work_stealing_stats.h>

Collaboration diagram for kcenon::thread::work_stealing_stats:

Public Member Functions
auto	steal_success_rate () const -> double
	Calculate the steal success rate.
auto	avg_batch_size () const -> double
	Calculate the average batch size.
auto	cross_node_ratio () const -> double
	Calculate the cross-NUMA node steal ratio.
auto	avg_steal_time_ns () const -> double
	Calculate average steal operation time.
void	reset ()
	Reset all statistics to zero.
auto	snapshot () const -> work_stealing_stats_snapshot
	Create a snapshot of current statistics.

Public Attributes
std::atomic< std::uint64_t >	steal_attempts {0}
	Total number of steal attempts.
std::atomic< std::uint64_t >	successful_steals {0}
	Number of successful steal operations.
std::atomic< std::uint64_t >	failed_steals {0}
	Number of failed steal operations.
std::atomic< std::uint64_t >	jobs_stolen {0}
	Total number of jobs successfully stolen.
std::atomic< std::uint64_t >	same_node_steals {0}
	Steals from workers on the same NUMA node.
std::atomic< std::uint64_t >	cross_node_steals {0}
	Steals from workers on different NUMA nodes.
std::atomic< std::uint64_t >	batch_steals {0}
	Number of batch steal operations (stealing multiple jobs)
std::atomic< std::uint64_t >	total_batch_size {0}
	Total size of all batch steals (for averaging)
std::atomic< std::uint64_t >	total_steal_time_ns {0}
	Total time spent in steal operations (nanoseconds)
std::atomic< std::uint64_t >	total_backoff_time_ns {0}
	Total time spent in backoff delays (nanoseconds)

Detailed Description

Statistics for work-stealing operations.

This structure tracks various metrics about work-stealing performance, including success rates, NUMA locality, batch efficiency, and timing. All counters are atomic for thread-safe updates from multiple workers.

Thread Safety

All members use atomic operations for lock-free concurrent updates. Statistics may show momentary inconsistencies during rapid updates but will eventually converge to accurate totals.

Memory Ordering

• Counter updates: relaxed ordering (eventual consistency acceptable)
• Snapshot reads: acquire ordering for consistent view

Usage Example

work_stealing_stats stats;
 
// After stealing operations
stats.steal_attempts.fetch_add(1, std::memory_order_relaxed);
stats.successful_steals.fetch_add(1, std::memory_order_relaxed);
stats.jobs_stolen.fetch_add(batch_size, std::memory_order_relaxed);
 
// Query statistics
double success_rate = stats.steal_success_rate();
double avg_batch = stats.avg_batch_size();
double cross_numa = stats.cross_node_ratio();

Definition at line 110 of file work_stealing_stats.h.

Member Function Documentation

avg_batch_size()

auto kcenon::thread::work_stealing_stats::avg_batch_size ( ) const -> double

inlinenodiscard

Calculate the average batch size.

Returns

Average number of jobs per batch steal

Returns 0.0 if no batch steals have been made.

Definition at line 185 of file work_stealing_stats.h.

    {
        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);
    }

References batch_steals, and total_batch_size.

avg_steal_time_ns()

auto kcenon::thread::work_stealing_stats::avg_steal_time_ns ( ) const -> double

inlinenodiscard

Calculate average steal operation time.

Returns

Average time per steal attempt in nanoseconds

Returns 0.0 if no steal attempts have been made.

Definition at line 221 of file work_stealing_stats.h.

    {
        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);
    }

References steal_attempts, and total_steal_time_ns.

cross_node_ratio()

auto kcenon::thread::work_stealing_stats::cross_node_ratio ( ) const -> double

inlinenodiscard

Calculate the cross-NUMA node steal ratio.

Returns

Ratio of cross-node steals to total steals (0.0 to 1.0)

Returns 0.0 if no successful steals have been made. Lower values indicate better NUMA locality.

Definition at line 203 of file work_stealing_stats.h.

    {
        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);
    }

References cross_node_steals, and same_node_steals.

reset()

void kcenon::thread::work_stealing_stats::reset ( )

inline

Reset all statistics to zero.

Thread Safety: This operation is not atomic across all counters. During reset, some counters may be zero while others retain old values. For accurate snapshots during operation, avoid calling reset() while steal operations are in progress.

Definition at line 241 of file work_stealing_stats.h.

    {
        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);
    }

References batch_steals, cross_node_steals, failed_steals, jobs_stolen, same_node_steals, steal_attempts, successful_steals, total_backoff_time_ns, total_batch_size, and total_steal_time_ns.

Referenced by kcenon::thread::numa_work_stealer::reset_stats().

Here is the caller graph for this function:

snapshot()

auto kcenon::thread::work_stealing_stats::snapshot ( ) const -> work_stealing_stats_snapshot

inlinenodiscard

Create a snapshot of current statistics.

Returns

A non-atomic copy of the current statistics

This creates a non-atomic snapshot that can be safely read without worrying about concurrent updates.

Definition at line 262 of file work_stealing_stats.h.

    {
        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;
    }

References batch_steals, kcenon::thread::work_stealing_stats_snapshot::batch_steals, cross_node_steals, kcenon::thread::work_stealing_stats_snapshot::cross_node_steals, failed_steals, kcenon::thread::work_stealing_stats_snapshot::failed_steals, jobs_stolen, kcenon::thread::work_stealing_stats_snapshot::jobs_stolen, same_node_steals, kcenon::thread::work_stealing_stats_snapshot::same_node_steals, steal_attempts, kcenon::thread::work_stealing_stats_snapshot::steal_attempts, successful_steals, kcenon::thread::work_stealing_stats_snapshot::successful_steals, total_backoff_time_ns, kcenon::thread::work_stealing_stats_snapshot::total_backoff_time_ns, total_batch_size, kcenon::thread::work_stealing_stats_snapshot::total_batch_size, total_steal_time_ns, and kcenon::thread::work_stealing_stats_snapshot::total_steal_time_ns.

Referenced by kcenon::thread::numa_work_stealer::get_stats_snapshot().

Here is the caller graph for this function:

steal_success_rate()

auto kcenon::thread::work_stealing_stats::steal_success_rate ( ) const -> double

inlinenodiscard

Calculate the steal success rate.

Returns

Success rate as a ratio (0.0 to 1.0)

Returns 0.0 if no steal attempts have been made.

Definition at line 168 of file work_stealing_stats.h.

    {
        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);
    }

References steal_attempts, and successful_steals.

Member Data Documentation

batch_steals

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::batch_steals {0}

Number of batch steal operations (stealing multiple jobs)

Definition at line 143 of file work_stealing_stats.h.

{0};

Referenced by avg_batch_size(), reset(), and snapshot().

cross_node_steals

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::cross_node_steals {0}

Steals from workers on different NUMA nodes.

Definition at line 136 of file work_stealing_stats.h.

{0};

Referenced by cross_node_ratio(), reset(), and snapshot().

failed_steals

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::failed_steals {0}

Number of failed steal operations.

Definition at line 123 of file work_stealing_stats.h.

{0};

Referenced by reset(), and snapshot().

jobs_stolen

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::jobs_stolen {0}

Total number of jobs successfully stolen.

Definition at line 126 of file work_stealing_stats.h.

{0};

Referenced by reset(), and snapshot().

same_node_steals

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::same_node_steals {0}

Steals from workers on the same NUMA node.

Definition at line 133 of file work_stealing_stats.h.

{0};

Referenced by cross_node_ratio(), reset(), and snapshot().

steal_attempts

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::steal_attempts {0}

Total number of steal attempts.

Definition at line 117 of file work_stealing_stats.h.

{0};

Referenced by avg_steal_time_ns(), reset(), snapshot(), and steal_success_rate().

successful_steals

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::successful_steals {0}

Number of successful steal operations.

Definition at line 120 of file work_stealing_stats.h.

{0};

Referenced by reset(), snapshot(), and steal_success_rate().

total_backoff_time_ns

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::total_backoff_time_ns {0}

Total time spent in backoff delays (nanoseconds)

Definition at line 156 of file work_stealing_stats.h.

{0};

Referenced by reset(), and snapshot().

total_batch_size

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::total_batch_size {0}

Total size of all batch steals (for averaging)

Definition at line 146 of file work_stealing_stats.h.

{0};

Referenced by avg_batch_size(), reset(), and snapshot().

total_steal_time_ns

std::atomic<std::uint64_t> kcenon::thread::work_stealing_stats::total_steal_time_ns {0}

Total time spent in steal operations (nanoseconds)

Definition at line 153 of file work_stealing_stats.h.

{0};

Referenced by avg_steal_time_ns(), reset(), and snapshot().

---

The documentation for this struct was generated from the following file:

• include/kcenon/thread/stealing/work_stealing_stats.h