work_affinity_tracker.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 <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
 
namespace kcenon::thread
{
 
class work_affinity_tracker
{
public:
    static constexpr std::size_t MAX_TRACKED_WORKERS = 32;
 
    explicit work_affinity_tracker(std::size_t worker_count,
                                   std::size_t history_size = 16);
 
    work_affinity_tracker() = default;
 
    work_affinity_tracker(work_affinity_tracker&& other) noexcept;
 
    auto operator=(work_affinity_tracker&& other) noexcept -> work_affinity_tracker&;
 
    // Deleted copy operations (contains atomics)
    work_affinity_tracker(const work_affinity_tracker&) = delete;
    auto operator=(const work_affinity_tracker&) -> work_affinity_tracker& = delete;
 
    ~work_affinity_tracker() = default;
 
    void record_cooperation(std::size_t thief_id, std::size_t victim_id);
 
    [[nodiscard]] auto get_affinity(std::size_t worker_a,
                                    std::size_t worker_b) const -> double;
 
    [[nodiscard]] auto get_preferred_victims(std::size_t worker_id,
                                             std::size_t max_count) const
        -> std::vector<std::size_t>;
 
    void reset();
 
    [[nodiscard]] auto worker_count() const -> std::size_t;
 
    [[nodiscard]] auto history_size() const -> std::size_t;
 
    [[nodiscard]] auto total_cooperations() const -> std::uint64_t;
 
private:
    [[nodiscard]] auto get_matrix_index(std::size_t worker_a,
                                        std::size_t worker_b) const -> std::size_t;
 
    static auto normalize_pair(std::size_t a, std::size_t b)
        -> std::pair<std::size_t, std::size_t>;
 
    std::size_t worker_count_{0};
    std::size_t tracked_count_{0};
    std::size_t history_size_{16};
    std::size_t matrix_size_{0};
 
    // Cooperation matrix stored as flattened upper triangular matrix
    // Entry (i,j) where i < j is at index: i * worker_count - i*(i+1)/2 + j - i - 1
    std::unique_ptr<std::atomic<std::uint64_t>[]> cooperation_matrix_;
 
    // Total cooperation events for normalization
    std::atomic<std::uint64_t> total_cooperations_{0};
};
 
} // namespace kcenon::thread