work_stealing_pool_policy.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 "pool_policy.h"
#include <kcenon/thread/core/worker_policy.h>
 
#include <atomic>
#include <memory>
#include <string>
 
namespace kcenon::thread
{
    // Forward declarations
    class thread_pool;
 
    class work_stealing_pool_policy : public pool_policy
    {
    public:
        explicit work_stealing_pool_policy(const worker_policy& config = {});
 
        ~work_stealing_pool_policy() override = default;
 
        // Non-copyable
        work_stealing_pool_policy(const work_stealing_pool_policy&) = delete;
        work_stealing_pool_policy& operator=(const work_stealing_pool_policy&) = delete;
 
        // Non-movable (std::atomic is not movable)
        work_stealing_pool_policy(work_stealing_pool_policy&&) = delete;
        work_stealing_pool_policy& operator=(work_stealing_pool_policy&&) = delete;
 
        // ============================================
        // pool_policy Interface
        // ============================================
 
        auto on_enqueue(job& j) -> common::VoidResult override;
 
        void on_job_start(job& j) override;
 
        void on_job_complete(job& j, bool success, const std::exception* error = nullptr) override;
 
        [[nodiscard]] auto get_name() const -> std::string override;
 
        [[nodiscard]] auto is_enabled() const -> bool override;
 
        void set_enabled(bool enabled) override;
 
        // ============================================
        // Work-Stealing Specific Methods
        // ============================================
 
        [[nodiscard]] auto get_policy() const -> const worker_policy&;
 
        void set_policy(const worker_policy& config);
 
        [[nodiscard]] auto get_steal_policy() const -> steal_policy;
 
        void set_steal_policy(steal_policy policy);
 
        [[nodiscard]] auto get_max_steal_attempts() const -> std::size_t;
 
        void set_max_steal_attempts(std::size_t attempts);
 
        [[nodiscard]] auto get_steal_backoff() const -> std::chrono::microseconds;
 
        void set_steal_backoff(std::chrono::microseconds backoff);
 
        [[nodiscard]] auto get_successful_steals() const -> std::uint64_t;
 
        [[nodiscard]] auto get_failed_steals() const -> std::uint64_t;
 
        void reset_stats();
 
        void record_successful_steal();
 
        void record_failed_steal();
 
    private:
        worker_policy policy_;
        std::atomic<bool> enabled_;
        std::atomic<std::uint64_t> successful_steals_{0};
        std::atomic<std::uint64_t> failed_steals_{0};
    };
 
} // namespace kcenon::thread