autoscaling_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 "scaling_metrics.h"
 
#include <chrono>
#include <cstddef>
#include <functional>
#include <thread>
 
namespace kcenon::thread
{
    struct autoscaling_policy
    {
        enum class mode
        {
            disabled,   
            manual,     
            automatic   
        };
 
        struct scale_up_config
        {
            double queue_depth_threshold = 100.0;
 
            double utilization_threshold = 0.8;
 
            double latency_threshold_ms = 50.0;
 
            std::size_t pending_jobs_threshold = 1000;
        };
 
        struct scale_down_config
        {
            double utilization_threshold = 0.3;
 
            double queue_depth_threshold = 10.0;
 
            std::chrono::seconds idle_duration{60};
        };
 
        // ============================================
        // Worker Bounds
        // ============================================
 
        std::size_t min_workers = 1;
 
        std::size_t max_workers = std::thread::hardware_concurrency();
 
        // ============================================
        // Trigger Configurations
        // ============================================
 
        scale_up_config scale_up;
 
        scale_down_config scale_down;
 
        // ============================================
        // Scaling Behavior
        // ============================================
 
        std::size_t scale_up_increment = 1;
 
        std::size_t scale_down_increment = 1;
 
        double scale_up_factor = 1.5;
 
        bool use_multiplicative_scaling = false;
 
        // ============================================
        // Cooldown Periods
        // ============================================
 
        std::chrono::seconds scale_up_cooldown{30};
 
        std::chrono::seconds scale_down_cooldown{60};
 
        // ============================================
        // Sampling Configuration
        // ============================================
 
        std::chrono::milliseconds sample_interval{1000};
 
        std::size_t samples_for_decision = 5;
 
        // ============================================
        // Mode
        // ============================================
 
        mode scaling_mode = mode::disabled;
 
        // ============================================
        // Callbacks
        // ============================================
 
        std::function<void(scaling_direction, scaling_reason, std::size_t, std::size_t)>
            scaling_callback;
 
        [[nodiscard]] auto is_valid() const -> bool
        {
            if (min_workers == 0)
            {
                return false;
            }
            if (max_workers < min_workers)
            {
                return false;
            }
            if (scale_up.utilization_threshold <= 0.0 || scale_up.utilization_threshold > 1.0)
            {
                return false;
            }
            if (scale_down.utilization_threshold < 0.0 || scale_down.utilization_threshold >= 1.0)
            {
                return false;
            }
            if (scale_down.utilization_threshold >= scale_up.utilization_threshold)
            {
                return false;
            }
            if (scale_up_increment == 0 || scale_down_increment == 0)
            {
                return false;
            }
            if (samples_for_decision == 0)
            {
                return false;
            }
            return true;
        }
    };
 
} // namespace kcenon::thread