thread_pool_builder.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/core/thread_pool.h>
#include <kcenon/thread/core/worker_policy.h>
#include <kcenon/thread/interfaces/thread_context.h>
#include <kcenon/thread/pool_policies/circuit_breaker_policy.h>
#include <kcenon/thread/pool_policies/autoscaling_pool_policy.h>
#include <kcenon/thread/pool_policies/work_stealing_pool_policy.h>
#include <kcenon/common/resilience/circuit_breaker_config.h>
#include <kcenon/thread/scaling/autoscaling_policy.h>
 
#include <memory>
#include <optional>
#include <string>
#include <thread>
#include <vector>
 
namespace kcenon::thread
{
    class thread_pool_builder
    {
    public:
        explicit thread_pool_builder(const std::string& name = "thread_pool");
 
        thread_pool_builder& with_workers(std::size_t count);
 
        thread_pool_builder& with_context(const thread_context& context);
 
        thread_pool_builder& with_queue(std::shared_ptr<job_queue> queue);
 
        thread_pool_builder& with_queue_adapter(
            std::unique_ptr<pool_queue_adapter_interface> adapter);
 
        thread_pool_builder& with_circuit_breaker(
            const circuit_breaker_config& config = {});
 
        thread_pool_builder& with_circuit_breaker(
            std::shared_ptr<circuit_breaker> cb);
 
        thread_pool_builder& with_autoscaling(
            const autoscaling_policy& config = {});
 
        thread_pool_builder& with_work_stealing();
 
        thread_pool_builder& with_work_stealing(const worker_policy& config);
 
        thread_pool_builder& with_diagnostics();
 
        thread_pool_builder& with_enhanced_metrics();
 
        thread_pool_builder& with_policy(std::unique_ptr<pool_policy> policy);
 
        [[nodiscard]] std::shared_ptr<thread_pool> build();
 
        [[nodiscard]] std::shared_ptr<thread_pool> build_and_start();
 
    private:
        std::string name_;
        std::size_t worker_count_{0};
        thread_context context_;
        std::shared_ptr<job_queue> custom_queue_;
        std::unique_ptr<pool_queue_adapter_interface> queue_adapter_;
        std::vector<std::unique_ptr<pool_policy>> policies_;
        bool enable_diagnostics_{false};
        bool enable_enhanced_metrics_{false};
 
        std::optional<circuit_breaker_config> circuit_breaker_config_;
        std::shared_ptr<circuit_breaker> shared_circuit_breaker_;
        std::optional<autoscaling_policy> autoscaling_config_;
        std::optional<worker_policy> work_stealing_config_;
 
        void reset();
    };
 
} // namespace kcenon::thread