priority_aging_config.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 <chrono>
#include <functional>
#include <string>
#include <cstdint>
 
namespace kcenon::thread
{
    struct job_info
    {
        std::string job_name;
        std::chrono::milliseconds wait_time;
        int priority_boost;
    };
 
    enum class aging_curve : uint8_t
    {
        linear,      
        exponential, 
        logarithmic  
    };
 
    struct priority_aging_config
    {
        bool enabled = false;
 
        std::chrono::milliseconds aging_interval{1000};
 
        int priority_boost_per_interval = 1;
 
        int max_priority_boost = 3;
 
        aging_curve curve = aging_curve::linear;
 
        double exponential_factor = 1.5;
 
        std::chrono::seconds starvation_threshold{30};
 
        std::function<void(const job_info&)> starvation_callback;
 
        bool reset_on_dequeue = true;
    };
 
    template<typename P>
    struct aged_priority
    {
        P base_priority;
 
        int boost{0};
 
        std::chrono::steady_clock::time_point enqueue_time;
 
        [[nodiscard]] auto effective_priority() const -> P
        {
            // For enum types, lower values typically mean higher priority
            // Subtracting boost moves toward higher priority (lower enum value)
            auto base_value = static_cast<int>(base_priority);
            auto boosted_value = base_value - boost;
            // Clamp to valid range (minimum 0)
            boosted_value = (boosted_value < 0) ? 0 : boosted_value;
            return static_cast<P>(boosted_value);
        }
 
        [[nodiscard]] auto wait_time() const -> std::chrono::milliseconds
        {
            return std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::steady_clock::now() - enqueue_time
            );
        }
 
        auto apply_boost(int boost_amount, int max_boost) -> void
        {
            boost += boost_amount;
            if (boost > max_boost)
            {
                boost = max_boost;
            }
        }
 
        auto reset_boost() -> void
        {
            boost = 0;
        }
 
        [[nodiscard]] auto is_max_boosted(int max_boost) const -> bool
        {
            return boost >= max_boost;
        }
    };
 
} // namespace kcenon::thread