kcenon::thread::autoscaling_pool_policy Class Reference

Pool policy that implements automatic scaling for dynamic worker management. More...

#include <autoscaling_pool_policy.h>

Inheritance diagram for kcenon::thread::autoscaling_pool_policy:

Collaboration diagram for kcenon::thread::autoscaling_pool_policy:

Public Member Functions
	autoscaling_pool_policy (thread_pool &pool, const autoscaling_policy &config={})
	Constructs an autoscaling pool policy with the given configuration.
	autoscaling_pool_policy (std::shared_ptr< autoscaler > scaler)
	Constructs an autoscaling pool policy with an existing autoscaler.
	~autoscaling_pool_policy () override
	Destructor. Stops the autoscaler if running.
	autoscaling_pool_policy (const autoscaling_pool_policy &)=delete
autoscaling_pool_policy &	operator= (const autoscaling_pool_policy &)=delete
	autoscaling_pool_policy (autoscaling_pool_policy &&)=delete
autoscaling_pool_policy &	operator= (autoscaling_pool_policy &&)=delete
auto	on_enqueue (job &j) -> common::VoidResult override
	Called before a job is enqueued.
void	on_job_start (job &j) override
	Called when job starts executing.
void	on_job_complete (job &j, bool success, const std::exception *error=nullptr) override
	Called when a job completes.
auto	get_name () const -> std::string override
	Gets the policy name.
auto	is_enabled () const -> bool override
	Checks if the policy is enabled.
void	set_enabled (bool enabled) override
	Enables or disables the policy.
void	start ()
	Starts the autoscaler monitor thread.
void	stop ()
	Stops the autoscaler monitor thread.
auto	is_active () const -> bool
	Checks if the autoscaler is currently active.
auto	get_autoscaler () const -> std::shared_ptr< autoscaler >
	Gets the underlying autoscaler.
auto	get_stats () const -> autoscaling_stats
	Gets current autoscaling statistics.
void	set_policy (const autoscaling_policy &config)
	Updates the autoscaling policy configuration.
auto	get_policy () const -> const autoscaling_policy &
	Gets the current autoscaling policy configuration.
auto	evaluate_now () -> scaling_decision
	Manually triggers a scaling evaluation.
auto	scale_to (std::size_t target_workers) -> common::VoidResult
	Manually scales to a specific worker count.
Public Member Functions inherited from kcenon::thread::pool_policy
virtual	~pool_policy ()=default
	Virtual destructor for proper cleanup.

Private Attributes
std::shared_ptr< autoscaler >	autoscaler_
std::atomic< bool >	enabled_ {true}

Detailed Description

Pool policy that implements automatic scaling for dynamic worker management.

This policy wraps the autoscaling functionality as a composable pool policy, enabling automatic scaling without modifying the thread_pool class.

Autoscaling Behavior

The autoscaler monitors thread pool metrics and adjusts worker count:

• Scale-up triggered when ANY threshold is exceeded (high utilization, queue depth, latency)
• Scale-down triggered when ALL conditions are met (low utilization, low queue depth, idle workers)

Thread Safety

All methods are thread-safe and can be called from any thread.

Usage Example

autoscaling_policy config;
config.min_workers = 2;
config.max_workers = 16;
config.scaling_mode = autoscaling_policy::mode::automatic;
 
auto as_policy = std::make_unique<autoscaling_pool_policy>(pool, config);
pool->add_policy(std::move(as_policy));
 
// Now workers are automatically scaled based on load

See also

pool_policy

autoscaler

autoscaling_policy

Definition at line 59 of file autoscaling_pool_policy.h.

Constructor & Destructor Documentation

autoscaling_pool_policy() [1/4]

kcenon::thread::autoscaling_pool_policy::autoscaling_pool_policy ( thread_pool & pool, const autoscaling_policy & config = {} )

explicit

Constructs an autoscaling pool policy with the given configuration.

Parameters

pool	Reference to the thread pool to manage.
config	Autoscaling policy configuration.

Definition at line 11 of file autoscaling_pool_policy.cpp.

    : autoscaler_(std::make_shared<autoscaler>(pool, config))
{
}

autoscaling_pool_policy() [2/4]

kcenon::thread::autoscaling_pool_policy::autoscaling_pool_policy ( std::shared_ptr< autoscaler > scaler )

explicit

Constructs an autoscaling pool policy with an existing autoscaler.

Parameters

scaler

Shared pointer to an existing autoscaler.

This allows sharing an autoscaler across multiple pools or components.

Definition at line 16 of file autoscaling_pool_policy.cpp.

    : autoscaler_(std::move(scaler))
{
}

~autoscaling_pool_policy()

kcenon::thread::autoscaling_pool_policy::~autoscaling_pool_policy ( )

override

Destructor. Stops the autoscaler if running.

Definition at line 21 of file autoscaling_pool_policy.cpp.

{
    if (autoscaler_ && autoscaler_->is_active()) {
        autoscaler_->stop();
    }
}

References autoscaler_.

autoscaling_pool_policy() [3/4]

kcenon::thread::autoscaling_pool_policy::autoscaling_pool_policy ( const autoscaling_pool_policy & )

delete

autoscaling_pool_policy() [4/4]

kcenon::thread::autoscaling_pool_policy::autoscaling_pool_policy ( autoscaling_pool_policy && )

delete

Member Function Documentation

evaluate_now()

auto kcenon::thread::autoscaling_pool_policy::evaluate_now ( ) -> scaling_decision

nodiscard

Manually triggers a scaling evaluation.

Returns

The scaling decision that would be made.

Definition at line 124 of file autoscaling_pool_policy.cpp.

{
    if (autoscaler_) {
        return autoscaler_->evaluate_now();
    }
    return scaling_decision{};
}

get_autoscaler()

auto kcenon::thread::autoscaling_pool_policy::get_autoscaler ( ) const -> std::shared_ptr<autoscaler>

nodiscard

Gets the underlying autoscaler.

Returns

Shared pointer to the autoscaler.

Useful for accessing detailed scaling controls and statistics.

Definition at line 95 of file autoscaling_pool_policy.cpp.

{
    return autoscaler_;
}

References autoscaler_.

get_name()

auto kcenon::thread::autoscaling_pool_policy::get_name ( ) const -> std::string

nodiscardoverridevirtual

Gets the policy name.

Returns

"autoscaling_pool_policy"

Implements kcenon::thread::pool_policy.

Definition at line 47 of file autoscaling_pool_policy.cpp.

{
    return "autoscaling_pool_policy";
}

get_policy()

auto kcenon::thread::autoscaling_pool_policy::get_policy ( ) const -> const autoscaling_policy&

nodiscard

Gets the current autoscaling policy configuration.

Returns

Const reference to the policy.

Definition at line 115 of file autoscaling_pool_policy.cpp.

{
    static autoscaling_policy default_policy;
    if (autoscaler_) {
        return autoscaler_->get_policy();
    }
    return default_policy;
}

References autoscaler_.

get_stats()

auto kcenon::thread::autoscaling_pool_policy::get_stats ( ) const -> autoscaling_stats

nodiscard

Gets current autoscaling statistics.

Returns

Statistics about scaling operations.

Definition at line 100 of file autoscaling_pool_policy.cpp.

{
    if (autoscaler_) {
        return autoscaler_->get_stats();
    }
    return autoscaling_stats{};
}

References autoscaler_.

is_active()

auto kcenon::thread::autoscaling_pool_policy::is_active ( ) const -> bool

nodiscard

Checks if the autoscaler is currently active.

Returns

True if the monitor thread is running.

Definition at line 90 of file autoscaling_pool_policy.cpp.

{
    return autoscaler_ && autoscaler_->is_active();
}

References autoscaler_.

is_enabled()

auto kcenon::thread::autoscaling_pool_policy::is_enabled ( ) const -> bool

nodiscardoverridevirtual

Checks if the policy is enabled.

Returns

True if enabled.

Reimplemented from kcenon::thread::pool_policy.

Definition at line 52 of file autoscaling_pool_policy.cpp.

{
    return enabled_.load(std::memory_order_acquire);
}

References enabled_.

on_enqueue()

auto kcenon::thread::autoscaling_pool_policy::on_enqueue ( job & j ) -> common::VoidResult

overridevirtual

Called before a job is enqueued.

Parameters

j	Reference to the job being enqueued.

Returns

common::ok() - autoscaling always allows jobs.

Autoscaling does not reject jobs; it adjusts worker count to handle load.

Implements kcenon::thread::pool_policy.

Definition at line 28 of file autoscaling_pool_policy.cpp.

{
    (void)j;  // Autoscaling does not reject jobs
    return common::ok();
}

on_job_complete()

void kcenon::thread::autoscaling_pool_policy::on_job_complete ( job & j, bool success, const std::exception * error = nullptr )

overridevirtual

Called when a job completes.

Parameters

j	Reference to the completed job.
success	True if job succeeded.
error	Exception pointer if job failed.

Records completion for metrics used in scaling decisions.

Implements kcenon::thread::pool_policy.

Definition at line 39 of file autoscaling_pool_policy.cpp.

{
    (void)j;
    (void)success;
    (void)error;
    // Metrics are collected by the autoscaler's monitor thread
}

References kcenon::thread::success.

on_job_start()

void kcenon::thread::autoscaling_pool_policy::on_job_start ( job & j )

overridevirtual

Called when job starts executing.

Parameters

j	Reference to the job.

Records job start for metrics collection.

Implements kcenon::thread::pool_policy.

Definition at line 34 of file autoscaling_pool_policy.cpp.

{
    (void)j;  // Metrics are collected by the autoscaler's monitor thread
}

operator=() [1/2]

autoscaling_pool_policy & kcenon::thread::autoscaling_pool_policy::operator= ( autoscaling_pool_policy && )

delete

operator=() [2/2]

autoscaling_pool_policy & kcenon::thread::autoscaling_pool_policy::operator= ( const autoscaling_pool_policy & )

delete

scale_to()

auto kcenon::thread::autoscaling_pool_policy::scale_to

(

std::size_t

target_workers

)

-> common::VoidResult

Manually scales to a specific worker count.

Parameters

target_workers

Desired number of workers.

Returns

Error if scaling fails.

Definition at line 132 of file autoscaling_pool_policy.cpp.

{
    if (autoscaler_) {
        return autoscaler_->scale_to(target_workers);
    }
    return common::ok();
}

set_enabled()

void kcenon::thread::autoscaling_pool_policy::set_enabled ( bool enabled )

overridevirtual

Enables or disables the policy.

Parameters

enabled

Whether to enable.

When disabled, the autoscaler is stopped. When enabled, it is started (if the pool is running).

Reimplemented from kcenon::thread::pool_policy.

Definition at line 57 of file autoscaling_pool_policy.cpp.

{
    bool was_enabled = enabled_.exchange(enabled, std::memory_order_acq_rel);
 
    if (autoscaler_) {
        if (enabled && !was_enabled) {
            // Transitioning to enabled - start the autoscaler
            if (!autoscaler_->is_active()) {
                autoscaler_->start();
            }
        } else if (!enabled && was_enabled) {
            // Transitioning to disabled - stop the autoscaler
            if (autoscaler_->is_active()) {
                autoscaler_->stop();
            }
        }
    }
}

References autoscaler_, and enabled_.

set_policy()

void kcenon::thread::autoscaling_pool_policy::set_policy

(

const autoscaling_policy &

config

)

Updates the autoscaling policy configuration.

Parameters

config

New policy configuration.

Definition at line 108 of file autoscaling_pool_policy.cpp.

{
    if (autoscaler_) {
        autoscaler_->set_policy(config);
    }
}

References autoscaler_.

start()

void kcenon::thread::autoscaling_pool_policy::start

(

)

Starts the autoscaler monitor thread.

Should be called after the pool starts. This is automatically managed if the policy is added before pool.start().

Definition at line 76 of file autoscaling_pool_policy.cpp.

{
    if (autoscaler_ && enabled_.load(std::memory_order_acquire)) {
        autoscaler_->start();
    }
}

References autoscaler_, and enabled_.

stop()

void kcenon::thread::autoscaling_pool_policy::stop

(

)

Stops the autoscaler monitor thread.

Definition at line 83 of file autoscaling_pool_policy.cpp.

{
    if (autoscaler_) {
        autoscaler_->stop();
    }
}

References autoscaler_.

Member Data Documentation

autoscaler_

std::shared_ptr<autoscaler> kcenon::thread::autoscaling_pool_policy::autoscaler_

private

Definition at line 205 of file autoscaling_pool_policy.h.

Referenced by get_autoscaler(), get_policy(), get_stats(), is_active(), set_enabled(), set_policy(), start(), stop(), and ~autoscaling_pool_policy().

enabled_

std::atomic<bool> kcenon::thread::autoscaling_pool_policy::enabled_ {true}

private

Definition at line 206 of file autoscaling_pool_policy.h.

{true};

Referenced by is_enabled(), set_enabled(), and start().

---

The documentation for this class was generated from the following files:

• include/kcenon/thread/pool_policies/autoscaling_pool_policy.h
• src/pool_policies/autoscaling_pool_policy.cpp