worker_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 <kcenon/thread/forward.h>
#include "config.h"
#include <chrono>
#include <string>
 
namespace kcenon::thread {
    
    enum class worker_state {
        created,     
        starting,    
        active,      
        idle,        
        stopping,    
        stopped      
    };
    
    enum class scheduling_policy {
        fifo,        
        lifo,        
        priority,    
        work_stealing 
    };
 
    enum class steal_policy {
        random,      
        round_robin, 
        adaptive     
    };
    
    struct worker_policy {
        // Scheduling behavior
        scheduling_policy scheduling = scheduling_policy::fifo;
        
        // Idle behavior
        std::chrono::milliseconds idle_timeout = config::default_worker_idle_timeout;
        bool yield_on_idle = config::default_yield_on_idle;
        bool sleep_when_idle = true;
        std::chrono::microseconds idle_sleep_duration{100};
        
        // Work stealing behavior
        bool enable_work_stealing = config::default_work_stealing;
        steal_policy victim_selection = steal_policy::random;
        size_t max_steal_attempts = 3;
        std::chrono::microseconds steal_backoff{50};
        
        // Performance behavior
        bool pin_to_cpu = config::default_pin_threads;
        int preferred_cpu = -1; // -1 means no preference
        size_t max_jobs_per_batch = 10;
        
        // Error handling
        bool continue_on_exception = true;
        size_t max_consecutive_failures = 5;
        
        // Debugging and monitoring
        bool enable_statistics = config::enable_statistics;
        std::string worker_name_prefix = config::default_thread_prefix;
        
        static worker_policy default_policy() {
            return worker_policy{};
        }
        
        static worker_policy high_performance() {
            worker_policy policy;
            policy.yield_on_idle = false;
            policy.sleep_when_idle = false;
            policy.enable_work_stealing = true;
            policy.max_jobs_per_batch = 20;
            return policy;
        }
        
        static worker_policy low_latency() {
            worker_policy policy;
            policy.scheduling = scheduling_policy::priority;
            policy.yield_on_idle = false;
            policy.idle_sleep_duration = std::chrono::microseconds{10};
            policy.max_jobs_per_batch = 1;
            return policy;
        }
        
        static worker_policy power_efficient() {
            worker_policy policy;
            policy.yield_on_idle = true;
            policy.sleep_when_idle = true;
            policy.idle_sleep_duration = std::chrono::milliseconds{1};
            policy.enable_work_stealing = false;
            return policy;
        }
    };
    
    constexpr const char* to_string(worker_state state) {
        switch (state) {
            case worker_state::created: return "created";
            case worker_state::starting: return "starting";
            case worker_state::active: return "active";
            case worker_state::idle: return "idle";
            case worker_state::stopping: return "stopping";
            case worker_state::stopped: return "stopped";
            default: return "unknown";
        }
    }
    
    constexpr const char* to_string(scheduling_policy policy) {
        switch (policy) {
            case scheduling_policy::fifo: return "fifo";
            case scheduling_policy::lifo: return "lifo";
            case scheduling_policy::priority: return "priority";
            case scheduling_policy::work_stealing: return "work_stealing";
            default: return "unknown";
        }
    }
 
    constexpr const char* to_string(steal_policy policy) {
        switch (policy) {
            case steal_policy::random: return "random";
            case steal_policy::round_robin: return "round_robin";
            case steal_policy::adaptive: return "adaptive";
            default: return "unknown";
        }
    }
 
} // namespace kcenon::thread