Concrete implementation of thread_pool_interface. More...

#include <thread_pool_adapter.h>

Inheritance diagram for kcenon::pacs::integration::thread_pool_adapter:

Collaboration diagram for kcenon::pacs::integration::thread_pool_adapter:

Public Member Functions
	thread_pool_adapter (const thread_pool_config &config)
	Construct adapter with configuration.

	thread_pool_adapter (std::shared_ptr< kcenon::thread::thread_pool > pool)
	Construct adapter with an existing thread pool.

	~thread_pool_adapter () override
	Destructor.

	thread_pool_adapter (const thread_pool_adapter &)=delete

thread_pool_adapter &	operator= (const thread_pool_adapter &)=delete

	thread_pool_adapter (thread_pool_adapter &&)=delete

thread_pool_adapter &	operator= (thread_pool_adapter &&)=delete

auto	start () -> bool override
	Start the thread pool.

auto	is_running () const noexcept -> bool override
	Check if the thread pool is running.

void	shutdown (bool wait_for_completion=true) override
	Shutdown the thread pool.

auto	submit (std::function< void()> task) -> std::future< void > override
	Submit a task for execution.

auto	submit_with_priority (job_priority priority, std::function< void()> task) -> std::future< void > override
	Submit a task with a specific priority level.

void	submit_fire_and_forget (std::function< void()> task) override
	Submit a task without waiting for completion.

auto	get_thread_count () const -> std::size_t override
	Get the current number of worker threads.

auto	get_pending_task_count () const -> std::size_t override
	Get the number of pending tasks in the queue.

auto	get_idle_worker_count () const -> std::size_t override
	Get the number of idle workers.

auto	get_underlying_pool () const -> std::shared_ptr< kcenon::thread::thread_pool >
	Get the underlying thread pool.

auto	get_config () const noexcept -> const thread_pool_config &
	Get the current configuration.

Public Member Functions inherited from kcenon::pacs::integration::thread_pool_interface
virtual	~thread_pool_interface ()=default
	Virtual destructor for proper polymorphic destruction.

Private Member Functions
void	submit_internal (std::function< void()> task, job_priority priority)
	Internal task submission with priority.

Private Attributes
std::shared_ptr< kcenon::thread::thread_pool >	pool_

thread_pool_config	config_

std::mutex	mutex_

bool	initialized_ {false}

Additional Inherited Members
Protected Member Functions inherited from kcenon::pacs::integration::thread_pool_interface
	thread_pool_interface ()=default
	Protected default constructor for derived classes.

	thread_pool_interface (const thread_pool_interface &)=delete
	Non-copyable.

thread_pool_interface &	operator= (const thread_pool_interface &)=delete

	thread_pool_interface (thread_pool_interface &&)=default
	Movable.

thread_pool_interface &	operator= (thread_pool_interface &&)=default

Detailed Description

Concrete implementation of thread_pool_interface.

This class adapts kcenon::thread::thread_pool to the thread_pool_interface, enabling dependency injection for thread pool operations in PACS components.

Key features:

Lock-free Job Queue: Uses thread_system's lock-free queue
Priority Scheduling: Critical operations get priority
Automatic Scaling: Thread pool grows/shrinks based on workload
Injectable: Can be passed to components via constructor

Thread Safety: All public methods are thread-safe.

Definition at line 65 of file thread_pool_adapter.h.

Constructor & Destructor Documentation

◆ thread_pool_adapter() [1/4]

kcenon::pacs::integration::thread_pool_adapter::thread_pool_adapter ( const thread_pool_config & config )

explicit

Construct adapter with configuration.

Creates a new thread pool with the specified configuration. The pool is not started until start() is called.

Parameters

config Configuration options for the thread pool

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 28 of file thread_pool_adapter.cpp.

    : config_(config) {
    // Validate configuration
    if (config_.min_threads == 0) {
        config_.min_threads = 1;
    }
    if (config_.max_threads < config_.min_threads) {
        config_.max_threads = config_.min_threads;
    }
 
    // Create the pool
    kcenon::thread::thread_context context;
    pool_ = std::make_shared<kcenon::thread::thread_pool>(config_.pool_name, context);
}

References config_, if(), kcenon::pacs::integration::thread_pool_config::max_threads, kcenon::pacs::integration::thread_pool_config::min_threads, pool_, and kcenon::pacs::integration::thread_pool_config::pool_name.

Here is the call graph for this function:

◆ thread_pool_adapter() [2/4]

kcenon::pacs::integration::thread_pool_adapter::thread_pool_adapter ( std::shared_ptr< kcenon::thread::thread_pool > pool )

explicit

Construct adapter with an existing thread pool.

Wraps an existing thread pool instance. This is useful for sharing a pool across multiple components or for testing.

Parameters

pool	Existing thread pool to wrap (must not be null)

Definition at line 43 of file thread_pool_adapter.cpp.

    : pool_(std::move(pool)), initialized_(true) {
    if (!pool_) {
        throw std::invalid_argument("Thread pool cannot be null");
    }
}

References pool_.

◆ ~thread_pool_adapter()

kcenon::pacs::integration::thread_pool_adapter::~thread_pool_adapter ( )

override

Destructor.

Shuts down the thread pool if it's still running.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 51 of file thread_pool_adapter.cpp.

                                          {
    shutdown(true);
}

References shutdown().

Here is the call graph for this function:

◆ thread_pool_adapter() [3/4]

kcenon::pacs::integration::thread_pool_adapter::thread_pool_adapter ( const thread_pool_adapter & )

delete

◆ thread_pool_adapter() [4/4]

kcenon::pacs::integration::thread_pool_adapter::thread_pool_adapter ( thread_pool_adapter && )

delete

Member Function Documentation

◆ get_config()

auto kcenon::pacs::integration::thread_pool_adapter::get_config ( ) const -> const thread_pool_config&

nodiscardnoexcept

Get the current configuration.

Returns: Current thread pool configuration

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 225 of file thread_pool_adapter.cpp.

                                                                                 {
    return config_;
}

References config_.

◆ get_idle_worker_count()

auto kcenon::pacs::integration::thread_pool_adapter::get_idle_worker_count ( ) const -> std::size_t

nodiscardoverridevirtual

Get the number of idle workers.

Returns: Number of workers not currently processing tasks

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 210 of file thread_pool_adapter.cpp.

                                                                   {
    std::lock_guard<std::mutex> lock(mutex_);
    return pool_ ? pool_->get_idle_worker_count() : 0;
}

References mutex_, and pool_.

◆ get_pending_task_count()

auto kcenon::pacs::integration::thread_pool_adapter::get_pending_task_count ( ) const -> std::size_t

nodiscardoverridevirtual

Get the number of pending tasks in the queue.

Returns: Number of tasks waiting to be processed

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 205 of file thread_pool_adapter.cpp.

                                                                    {
    std::lock_guard<std::mutex> lock(mutex_);
    return pool_ ? pool_->get_pending_task_count() : 0;
}

References mutex_, and pool_.

◆ get_thread_count()

auto kcenon::pacs::integration::thread_pool_adapter::get_thread_count ( ) const -> std::size_t

nodiscardoverridevirtual

Get the current number of worker threads.

Returns: Number of active worker threads

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 198 of file thread_pool_adapter.cpp.

                                                              {
    std::lock_guard<std::mutex> lock(mutex_);
    // Return configured thread count if pool is initialized
    // This reflects the expected worker count rather than transient active state
    return initialized_ ? config_.min_threads : 0;
}

References config_, initialized_, kcenon::pacs::integration::thread_pool_config::min_threads, and mutex_.

◆ get_underlying_pool()

auto kcenon::pacs::integration::thread_pool_adapter::get_underlying_pool ( ) const -> std::shared_ptr<kcenon::thread::thread_pool>

nodiscard

Get the underlying thread pool.

Provides access to the underlying kcenon::thread::thread_pool for advanced use cases. Use with caution.

Returns: Shared pointer to the underlying thread pool

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 219 of file thread_pool_adapter.cpp.

                                              {
    std::lock_guard<std::mutex> lock(mutex_);
    return pool_;
}

References mutex_, and pool_.

◆ is_running()

auto kcenon::pacs::integration::thread_pool_adapter::is_running ( ) const -> bool

nodiscardoverridevirtualnoexcept

Check if the thread pool is running.

Returns: true if the pool is active and accepting tasks

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 97 of file thread_pool_adapter.cpp.

                                                            {
    std::lock_guard<std::mutex> lock(mutex_);
    return pool_ && pool_->is_running();
}

References mutex_, and pool_.

Referenced by submit_internal().

Here is the caller graph for this function:

◆ operator=() [1/2]

thread_pool_adapter & kcenon::pacs::integration::thread_pool_adapter::operator= ( const thread_pool_adapter & )

delete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

◆ operator=() [2/2]

thread_pool_adapter & kcenon::pacs::integration::thread_pool_adapter::operator= ( thread_pool_adapter && )

delete

◆ shutdown()

void kcenon::pacs::integration::thread_pool_adapter::shutdown ( bool wait_for_completion = true )

overridevirtual

Shutdown the thread pool.

Stops accepting new tasks and optionally waits for pending tasks.

Parameters

wait_for_completion If true, waits for all pending tasks to complete

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 102 of file thread_pool_adapter.cpp.

                                                           {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (pool_) {
        pool_->stop(!wait_for_completion);
    }
 
    initialized_ = false;
}

References initialized_, mutex_, and pool_.

Referenced by ~thread_pool_adapter().

Here is the caller graph for this function:

◆ start()

auto kcenon::pacs::integration::thread_pool_adapter::start ( ) -> bool

nodiscardoverridevirtual

Start the thread pool.

Initializes worker threads and begins accepting tasks. Safe to call multiple times; subsequent calls are no-ops if running.

Returns: true if started successfully or already running, false otherwise

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 59 of file thread_pool_adapter.cpp.

                                        {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (initialized_ && pool_ && pool_->is_running()) {
        return true;  // Already running
    }
 
    // Create pool if not exists
    if (!pool_) {
        kcenon::thread::thread_context context;
        pool_ = std::make_shared<kcenon::thread::thread_pool>(config_.pool_name, context);
    }
 
    // Create worker threads
    std::vector<std::unique_ptr<kcenon::thread::thread_worker>> workers;
    workers.reserve(config_.min_threads);
 
    kcenon::thread::thread_context context;
    for (std::size_t i = 0; i < config_.min_threads; ++i) {
        workers.push_back(std::make_unique<kcenon::thread::thread_worker>(false, context));
    }
 
    // Enqueue workers
    auto enqueue_result = pool_->enqueue_batch(std::move(workers));
    if (enqueue_result.is_err()) {
        return false;
    }
 
    // Start the pool
    auto start_result = pool_->start();
    if (start_result.is_err()) {
        return false;
    }
 
    initialized_ = true;
    return true;
}

Referenced by submit_internal().

Here is the caller graph for this function:

◆ submit()

auto kcenon::pacs::integration::thread_pool_adapter::submit ( std::function< void()> task ) -> std::future< void >

nodiscardoverridevirtual

Submit a task for execution.

Submits a void-returning task to the thread pool for asynchronous execution with normal priority.

Parameters

task	The task to execute (must be callable with no arguments)

Returns: Future that completes when the task finishes

Exceptions

std::runtime_error if pool is not running

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 116 of file thread_pool_adapter.cpp.

                       {
    auto promise = std::make_shared<std::promise<void>>();
    auto future = promise->get_future();
 
    submit_internal(
        [task = std::move(task), promise]() mutable {
            try {
                task();
                promise->set_value();
            } catch (...) {
                promise->set_exception(std::current_exception());
            }
        },
        job_priority::normal);
 
    return future;
}

References kcenon::pacs::integration::normal.

◆ submit_fire_and_forget()

void kcenon::pacs::integration::thread_pool_adapter::submit_fire_and_forget ( std::function< void()> task )

overridevirtual

Submit a task without waiting for completion.

Fire-and-forget submission for tasks where the result is not needed. Errors are logged but not propagated.

Parameters

task	The task to execute

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 155 of file thread_pool_adapter.cpp.

                                                                         {
    submit_internal(std::move(task), job_priority::low);
}

References kcenon::pacs::integration::low, and submit_internal().

Here is the call graph for this function:

◆ submit_internal()

void kcenon::pacs::integration::thread_pool_adapter::submit_internal	(	std::function< void()>	task,
		job_priority	priority )

private

Internal task submission with priority.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 159 of file thread_pool_adapter.cpp.

                    {
    // Ensure pool is started
    if (!is_running()) {
        if (!start()) {
            throw std::runtime_error("Failed to start thread pool");
        }
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
    if (pool_) {
        // Use job_builder for modern API (replaces deprecated future_job)
        // Note: Priority is not currently used as the base thread_pool
        // doesn't support it. For future implementation, consider using
        // typed_thread_pool or a priority queue wrapper.
        try {
            auto job = kcenon::thread::job_builder()
                .name("pacs_pool_task")
                .work([task = std::move(task)]() -> kcenon::common::VoidResult {
                    task();
                    return kcenon::common::ok();
                })
                .build();
 
            auto result = pool_->enqueue(std::move(job));
            if (result.is_err()) {
                throw std::runtime_error("Failed to enqueue task to thread pool");
            }
        } catch (const std::exception&) {
            throw std::runtime_error("Failed to enqueue task to thread pool");
        }
    }
}

References is_running(), mutex_, pool_, and start().

Referenced by submit_fire_and_forget().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ submit_with_priority()

auto kcenon::pacs::integration::thread_pool_adapter::submit_with_priority	(	job_priority	priority,
		std::function< void()>	task ) -> std::future< void >

nodiscardoverridevirtual

Submit a task with a specific priority level.

Jobs with higher priority (lower enum value) are processed first.

Parameters

priority	The priority level for this task
task	The task to execute

Returns: Future that completes when the task finishes

Exceptions

std::runtime_error if pool is not running

Implements kcenon::pacs::integration::thread_pool_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 135 of file thread_pool_adapter.cpp.

                                                 {
    auto promise = std::make_shared<std::promise<void>>();
    auto future = promise->get_future();
 
    submit_internal(
        [task = std::move(task), promise]() mutable {
            try {
                task();
                promise->set_value();
            } catch (...) {
                promise->set_exception(std::current_exception());
            }
        },
        priority);
 
    return future;
}

Member Data Documentation

◆ config_

thread_pool_config kcenon::pacs::integration::thread_pool_adapter::config_

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 160 of file thread_pool_adapter.h.

Referenced by get_config(), get_thread_count(), and thread_pool_adapter().

◆ initialized_

bool kcenon::pacs::integration::thread_pool_adapter::initialized_ {false}

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 162 of file thread_pool_adapter.h.

162{false};

Referenced by get_thread_count(), and shutdown().

◆ mutex_

std::mutex kcenon::pacs::integration::thread_pool_adapter::mutex_

mutableprivate

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 161 of file thread_pool_adapter.h.

Referenced by get_idle_worker_count(), get_pending_task_count(), get_thread_count(), get_underlying_pool(), is_running(), shutdown(), and submit_internal().

◆ pool_

std::shared_ptr<kcenon::thread::thread_pool> kcenon::pacs::integration::thread_pool_adapter::pool_

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/thread_pool_adapter.h.

Definition at line 159 of file thread_pool_adapter.h.

Referenced by get_idle_worker_count(), get_pending_task_count(), get_underlying_pool(), is_running(), shutdown(), submit_internal(), thread_pool_adapter(), and thread_pool_adapter().

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

include/kcenon/pacs/integration/thread_pool_adapter.h
src/integration/thread_pool_adapter.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ thread_pool_adapter() [1/4]

◆ thread_pool_adapter() [2/4]

◆ ~thread_pool_adapter()

◆ thread_pool_adapter() [3/4]

◆ thread_pool_adapter() [4/4]

Member Function Documentation

◆ get_config()

◆ get_idle_worker_count()

◆ get_pending_task_count()

◆ get_thread_count()

◆ get_underlying_pool()

◆ is_running()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ shutdown()

◆ start()

◆ submit()

◆ submit_fire_and_forget()

◆ submit_internal()

◆ submit_with_priority()

Member Data Documentation

◆ config_

◆ initialized_

◆ mutex_

◆ pool_