kcenon::thread::adaptive_job_queue Class Reference

Adaptive queue that switches between mutex and lock-free modes. More...

#include <adaptive_job_queue.h>

Inheritance diagram for kcenon::thread::adaptive_job_queue:

Collaboration diagram for kcenon::thread::adaptive_job_queue:

Classes
class	accuracy_guard
	RAII guard that temporarily switches to accuracy mode. More...
struct	stats
	Statistics about mode switching. More...

Public Types
enum class	mode { mutex , lock_free }
	Operating mode. More...
enum class	policy { accuracy_first , performance_first , balanced , manual }
	Selection policy. More...

Public Member Functions
	adaptive_job_queue (policy p=policy::balanced)
	Create adaptive queue with specified policy.
	~adaptive_job_queue ()
	Destructor - cleans up both queue implementations.
	adaptive_job_queue (const adaptive_job_queue &)=delete
adaptive_job_queue &	operator= (const adaptive_job_queue &)=delete
	adaptive_job_queue (adaptive_job_queue &&)=delete
adaptive_job_queue &	operator= (adaptive_job_queue &&)=delete
auto	schedule (std::unique_ptr< job > &&work) -> common::VoidResult override
	Schedule a job (delegates to current queue)
auto	get_next_job () -> common::Result< std::unique_ptr< job > > override
	Get next job (delegates to current queue)
auto	enqueue (std::unique_ptr< job > &&j) -> common::VoidResult
	Enqueues a job into the current active queue.
template<typename JobType , typename = std::enable_if_t<std::is_base_of_v<job, JobType>>>
auto	enqueue (std::unique_ptr< JobType > &&value) -> common::VoidResult
	Type-safe enqueue for job subclasses.
auto	dequeue () -> common::Result< std::unique_ptr< job > >
	Dequeues a job from the current active queue.
auto	try_dequeue () -> common::Result< std::unique_ptr< job > >
	Tries to dequeue a job without blocking.
auto	empty () const -> bool
	Checks if the queue is empty.
auto	size () const -> std::size_t
	Returns the current number of jobs in the queue.
auto	clear () -> void
	Clears all jobs from the queue.
auto	stop () -> void
	Signals the queue to stop.
auto	is_stopped () const -> bool
	Checks if the queue is stopped.
auto	get_capabilities () const -> queue_capabilities override
	Returns capabilities based on current mode.
auto	current_mode () const -> mode
	Get current operating mode.
auto	current_policy () const -> policy
	Get current policy.
auto	switch_mode (mode m) -> common::VoidResult
	Manually switch mode (only if policy is manual)
auto	get_stats () const -> stats
	Get statistics about queue usage.
auto	require_accuracy () -> accuracy_guard
	Request temporary accuracy mode.
Public Member Functions inherited from kcenon::thread::scheduler_interface
virtual	~scheduler_interface ()=default
Public Member Functions inherited from kcenon::thread::queue_capabilities_interface
virtual	~queue_capabilities_interface ()=default
auto	has_exact_size () const -> bool
	Check if size() returns exact values.
auto	has_atomic_empty () const -> bool
	Check if empty() check is atomic.
auto	is_lock_free () const -> bool
	Check if this is a lock-free implementation.
auto	is_wait_free () const -> bool
	Check if this is a wait-free implementation.
auto	supports_batch () const -> bool
	Check if batch operations are supported.
auto	supports_blocking_wait () const -> bool
	Check if blocking wait is supported.
auto	supports_stop () const -> bool
	Check if stop signaling is supported.

Private Member Functions
void	migrate_to_mode (mode target)
void	update_mode_time ()
auto	determine_mode_for_balanced () const -> mode

Private Attributes
policy	policy_
std::atomic< mode >	current_mode_
std::atomic< bool >	stopped_ {false}
std::shared_ptr< job_queue >	mutex_queue_
std::unique_ptr< detail::lockfree_job_queue >	lockfree_queue_
std::mutex	migration_mutex_
std::atomic< int >	accuracy_guard_count_ {0}
std::mutex	stats_mutex_
stats	stats_
std::chrono::steady_clock::time_point	mode_start_time_

Detailed Description

Adaptive queue that switches between mutex and lock-free modes.

This class WRAPS existing job_queue and lockfree_job_queue, providing automatic or manual mode switching based on requirements.

Note

This is a NEW class. Existing job_queue and lockfree_job_queue are UNCHANGED and can still be used directly.

Key Features

• Wraps both mutex-based and lock-free queue implementations
• Supports multiple selection policies (accuracy, performance, balanced, manual)
• Provides RAII guard for temporary accuracy mode
• Thread-safe mode switching with data migration
• Statistics tracking for mode switches and time spent in each mode

Usage

// Create adaptive queue (defaults to balanced policy)
auto queue = std::make_unique<adaptive_job_queue>();
 
// Use like any other queue
queue->enqueue(std::make_unique<my_job>());
auto job = queue->dequeue();
 
// Temporarily require accuracy
{
    auto guard = queue->require_accuracy();
    size_t exact = queue->size();  // Now guaranteed exact
}

Examples

adaptive_queue_sample.cpp.

Definition at line 60 of file adaptive_job_queue.h.

Member Enumeration Documentation

mode

enum class kcenon::thread::adaptive_job_queue::mode

strong

Operating mode.

Enumerator
mutex	Using job_queue (accuracy mode)
lock_free	Using lockfree_job_queue (performance mode)

Definition at line 66 of file adaptive_job_queue.h.

                    {
        mutex,     
        lock_free  
    };

policy

enum class kcenon::thread::adaptive_job_queue::policy

strong

Selection policy.

Enumerator
accuracy_first	Always use mutex mode.
performance_first	Always use lock-free mode.
balanced	Auto-switch based on usage.
manual	User controls mode.

Definition at line 74 of file adaptive_job_queue.h.

                      {
        accuracy_first,    
        performance_first, 
        balanced,          
        manual             
    };

Constructor & Destructor Documentation

adaptive_job_queue() [1/3]

kcenon::thread::adaptive_job_queue::adaptive_job_queue ( policy p = policy::balanced )

explicit

Create adaptive queue with specified policy.

Parameters

p	Selection policy (default: balanced)

Definition at line 13 of file adaptive_job_queue.cpp.

    : policy_(p)
    , current_mode_(mode::mutex)
    , mutex_queue_(std::make_shared<job_queue>())
    , lockfree_queue_(std::make_unique<detail::lockfree_job_queue>())
    , mode_start_time_(std::chrono::steady_clock::now()) {
 
    // Set initial mode based on policy
    switch (policy_) {
        case policy::accuracy_first:
            current_mode_.store(mode::mutex, std::memory_order_release);
            break;
        case policy::performance_first:
            current_mode_.store(mode::lock_free, std::memory_order_release);
            break;
        case policy::balanced:
        case policy::manual:
            // Default to mutex mode for balanced and manual
            current_mode_.store(mode::mutex, std::memory_order_release);
            break;
    }
}

References accuracy_first, balanced, current_mode_, lock_free, manual, mutex, performance_first, and policy_.

~adaptive_job_queue()

kcenon::thread::adaptive_job_queue::~adaptive_job_queue

(

)

Destructor - cleans up both queue implementations.

Definition at line 36 of file adaptive_job_queue.cpp.

                                        {
    // Stop and clear both queues
    stop();
 
    // Update final mode time
    update_mode_time();
}

References stop(), and update_mode_time().

Here is the call graph for this function:

adaptive_job_queue() [2/3]

kcenon::thread::adaptive_job_queue::adaptive_job_queue ( const adaptive_job_queue & )

delete

adaptive_job_queue() [3/3]

kcenon::thread::adaptive_job_queue::adaptive_job_queue ( adaptive_job_queue && )

delete

Member Function Documentation

clear()

auto kcenon::thread::adaptive_job_queue::clear

(

)

-> void

Clears all jobs from the queue.

Definition at line 160 of file adaptive_job_queue.cpp.

                                       {
    std::lock_guard<std::mutex> lock(migration_mutex_);
 
    mutex_queue_->clear();
    // lockfree_queue doesn't have clear(), drain it
    while (true) {
        auto result = lockfree_queue_->dequeue();
        if (result.is_err()) {
            break;
        }
        // Jobs are destroyed when unique_ptr goes out of scope
    }
}

current_mode()

auto kcenon::thread::adaptive_job_queue::current_mode ( ) const -> mode

nodiscard

Get current operating mode.

Returns

Current mode (mutex or lock_free)

Definition at line 217 of file adaptive_job_queue.cpp.

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

References current_mode_.

Referenced by adaptive_behavior_example(), different_policies_example(), and performance_monitoring_example().

Here is the caller graph for this function:

current_policy()

auto kcenon::thread::adaptive_job_queue::current_policy ( ) const -> policy

nodiscard

Get current policy.

Returns

Current selection policy

Definition at line 221 of file adaptive_job_queue.cpp.

                                                        {
    return policy_;
}

References policy_.

dequeue()

auto kcenon::thread::adaptive_job_queue::dequeue ( ) -> common::Result<std::unique_ptr<job>>

nodiscard

Dequeues a job from the current active queue.

Returns

common::Result<std::unique_ptr<job>> The dequeued job or error

Definition at line 82 of file adaptive_job_queue.cpp.

                                                                     {
    if (stopped_.load(std::memory_order_acquire)) {
        return common::error_info{static_cast<int>(error_code::queue_stopped), "Queue is stopped", "thread_system"};
    }
 
    common::Result<std::unique_ptr<job>> result = common::error_info{static_cast<int>(error_code::queue_empty), "Queue is empty", "thread_system"};
    mode current = current_mode_.load(std::memory_order_acquire);
 
    // Try current mode first
    if (current == mode::mutex) {
        result = mutex_queue_->try_dequeue();
        // If current mode is empty, also check other queue for race condition handling
        if (result.is_err()) {
            result = lockfree_queue_->dequeue();
        }
    } else {
        result = lockfree_queue_->dequeue();
        // If current mode is empty, also check other queue for race condition handling
        if (result.is_err()) {
            result = mutex_queue_->try_dequeue();
        }
    }
 
    if (result.is_ok()) {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        ++stats_.dequeue_count;
    }
 
    return result;
}

References kcenon::thread::result< T >::is_ok(), kcenon::thread::queue_empty, and kcenon::thread::queue_stopped.

Referenced by adaptive_behavior_example(), different_policies_example(), performance_monitoring_example(), policy_comparison_example(), and web_server_simulation().

Here is the call graph for this function:

Here is the caller graph for this function:

determine_mode_for_balanced()

auto kcenon::thread::adaptive_job_queue::determine_mode_for_balanced ( ) const -> mode

private

Definition at line 392 of file adaptive_job_queue.cpp.

                                                                   {
    // For balanced policy, use heuristics based on recent activity
    // Current simple heuristic: prefer lock-free for high throughput
 
    std::lock_guard<std::mutex> lock(stats_mutex_);
 
    // If we've processed a lot of jobs, prefer lock-free for performance
    uint64_t total_ops = stats_.enqueue_count + stats_.dequeue_count;
    if (total_ops > 10000) {
        return mode::lock_free;
    }
 
    // For lower throughput, prefer mutex for accuracy
    return mode::mutex;
}

References kcenon::thread::adaptive_job_queue::stats::dequeue_count, kcenon::thread::adaptive_job_queue::stats::enqueue_count, lock_free, mutex, stats_, and stats_mutex_.

empty()

auto kcenon::thread::adaptive_job_queue::empty ( ) const -> bool

nodiscard

Checks if the queue is empty.

Returns

true if queue is empty, false otherwise

Note

Accuracy depends on current mode

Definition at line 144 of file adaptive_job_queue.cpp.

                                             {
    // Check both queues to handle race conditions during mode transitions
    // During migration, items may temporarily exist in either queue
    return mutex_queue_->empty() && lockfree_queue_->empty();
}

References lockfree_queue_, and mutex_queue_.

Referenced by different_policies_example().

Here is the caller graph for this function:

enqueue() [1/2]

auto kcenon::thread::adaptive_job_queue::enqueue ( std::unique_ptr< job > && j ) -> common::VoidResult

nodiscard

Enqueues a job into the current active queue.

Parameters

j	Unique pointer to the job being added

Returns

common::VoidResult indicating success or error

Definition at line 60 of file adaptive_job_queue.cpp.

                                                                           {
    if (stopped_.load(std::memory_order_acquire)) {
        return common::error_info{static_cast<int>(error_code::queue_stopped), "Queue is stopped", "thread_system"};
    }
 
    if (!j) {
        return common::error_info{static_cast<int>(error_code::invalid_argument), "Cannot enqueue null job", "thread_system"};
    }
 
    mode current = current_mode_.load(std::memory_order_acquire);
    common::VoidResult result = (current == mode::mutex)
        ? mutex_queue_->enqueue(std::move(j))
        : lockfree_queue_->enqueue(std::move(j));
 
    if (result.is_ok()) {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        ++stats_.enqueue_count;
    }
 
    return result;
}

References kcenon::thread::invalid_argument, kcenon::thread::result< T >::is_ok(), and kcenon::thread::queue_stopped.

Referenced by adaptive_behavior_example(), different_policies_example(), enqueue(), performance_monitoring_example(), policy_comparison_example(), and web_server_simulation().

Here is the call graph for this function:

Here is the caller graph for this function:

enqueue() [2/2]

template<typename JobType , typename = std::enable_if_t<std::is_base_of_v<job, JobType>>>

auto kcenon::thread::adaptive_job_queue::enqueue ( std::unique_ptr< JobType > && value ) -> common::VoidResult

inlinenodiscard

Type-safe enqueue for job subclasses.

This template method provides type-safe job submission, allowing callers to enqueue jobs without explicit casting. The JobType must be derived from the base job class.

Template Parameters

JobType

A type derived from job

Parameters

value

A unique pointer to the job being added.

Returns

common::VoidResult indicating success or error

auto queue = std::make_unique<adaptive_job_queue>();
queue->enqueue<my_custom_job>(std::make_unique<my_custom_job>());

Definition at line 149 of file adaptive_job_queue.h.

    {
        return enqueue(std::unique_ptr<job>(std::move(value)));
    }

References enqueue().

Here is the call graph for this function:

get_capabilities()

auto kcenon::thread::adaptive_job_queue::get_capabilities ( ) const -> queue_capabilities

nodiscardoverridevirtual

Returns capabilities based on current mode.

Returns

Queue capabilities struct

Note

Capabilities change based on current operating mode:

• Mutex mode: exact_size=true, atomic_empty_check=true, lock_free=false
• Lock-free mode: exact_size=false, atomic_empty_check=false, lock_free=true

Reimplemented from kcenon::thread::queue_capabilities_interface.

Definition at line 187 of file adaptive_job_queue.cpp.

                                                                      {
    mode current = current_mode_.load(std::memory_order_acquire);
 
    if (current == mode::mutex) {
        return queue_capabilities{
            .exact_size = true,
            .atomic_empty_check = true,
            .lock_free = false,
            .wait_free = false,
            .supports_batch = true,
            .supports_blocking_wait = true,
            .supports_stop = true
        };
    } else {
        return queue_capabilities{
            .exact_size = false,
            .atomic_empty_check = false,
            .lock_free = true,
            .wait_free = false,
            .supports_batch = false,
            .supports_blocking_wait = false,
            .supports_stop = true
        };
    }
}

References current_mode_, and mutex.

get_next_job()

auto kcenon::thread::adaptive_job_queue::get_next_job ( ) -> common::Result<std::unique_ptr<job>>

overridevirtual

Get next job (delegates to current queue)

Returns

common::Result<std::unique_ptr<job>> The dequeued job or error

Implements kcenon::thread::scheduler_interface.

Definition at line 52 of file adaptive_job_queue.cpp.

                                                                          {
    return dequeue();
}

get_stats()

auto kcenon::thread::adaptive_job_queue::get_stats ( ) const -> stats

nodiscard

Get statistics about queue usage.

Returns

Current statistics

Definition at line 239 of file adaptive_job_queue.cpp.

                                                  {
    std::lock_guard<std::mutex> lock(stats_mutex_);
 
    // Create a copy of stats with updated time
    stats result = stats_;
 
    // Add current mode time
    auto now = std::chrono::steady_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
        now - mode_start_time_).count();
 
    if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
        result.time_in_mutex_ms += duration;
    } else {
        result.time_in_lockfree_ms += duration;
    }
 
    return result;
}

References current_mode_, mode_start_time_, mutex, stats_, and stats_mutex_.

Referenced by performance_monitoring_example(), and web_server_simulation().

Here is the caller graph for this function:

is_stopped()

auto kcenon::thread::adaptive_job_queue::is_stopped ( ) const -> bool

nodiscard

Checks if the queue is stopped.

Returns

true if stopped, false otherwise

Definition at line 179 of file adaptive_job_queue.cpp.

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

References stopped_.

migrate_to_mode()

void kcenon::thread::adaptive_job_queue::migrate_to_mode ( mode target )

private

Definition at line 330 of file adaptive_job_queue.cpp.

                                                    {
    std::lock_guard<std::mutex> lock(migration_mutex_);
 
    mode current = current_mode_.load(std::memory_order_acquire);
    if (current == target) {
        return; // Already in target mode
    }
 
    // Update time tracking before mode change
    update_mode_time();
 
    // IMPORTANT: Update mode FIRST, then drain the old queue.
    // This ensures new enqueues go to the target queue while we drain,
    // preventing an infinite drain loop where the producer keeps adding
    // to the source queue faster than we can drain it.
    current_mode_.store(target, std::memory_order_release);
 
    if (target == mode::mutex) {
        // Migrate from lock-free to mutex
        // Drain remaining jobs from lockfree queue and move to mutex queue
        while (true) {
            auto result = lockfree_queue_->dequeue();
            if (result.is_err()) {
                break;
            }
            (void)mutex_queue_->enqueue(std::move(result.value()));
        }
    } else {
        // Migrate from mutex to lock-free
        // Drain mutex queue and move jobs to lockfree queue
        auto jobs = mutex_queue_->dequeue_batch();
        for (auto& job : jobs) {
            (void)lockfree_queue_->enqueue(std::move(job));
        }
    }
 
    // Update statistics
    {
        std::lock_guard<std::mutex> stats_lock(stats_mutex_);
        ++stats_.mode_switches;
    }
 
    // Reset mode start time
    mode_start_time_ = std::chrono::steady_clock::now();
}

References current_mode_, lockfree_queue_, migration_mutex_, mode_start_time_, kcenon::thread::adaptive_job_queue::stats::mode_switches, mutex, mutex_queue_, stats_, stats_mutex_, update_mode_time(), and kcenon::thread::result< T >::value().

Referenced by kcenon::thread::adaptive_job_queue::accuracy_guard::accuracy_guard().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

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

delete

operator=() [2/2]

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

delete

require_accuracy()

auto kcenon::thread::adaptive_job_queue::require_accuracy ( ) -> accuracy_guard

nodiscard

Request temporary accuracy mode.

Returns

Guard object - mode reverts when guard is destroyed

Note

While the guard is active:

• Queue operates in mutex mode
• size() returns exact count
• empty() is atomically consistent

auto queue = std::make_unique<adaptive_job_queue>();
{
    auto guard = queue->require_accuracy();
    // In this scope, size() is guaranteed exact
    if (queue->size() > 1000) {
        apply_backpressure();
    }
}
// After scope, may revert to lock-free mode

Definition at line 259 of file adaptive_job_queue.cpp.

                                                            {
    return accuracy_guard(*this);
}

schedule()

auto kcenon::thread::adaptive_job_queue::schedule ( std::unique_ptr< job > && work ) -> common::VoidResult

overridevirtual

Schedule a job (delegates to current queue)

Parameters

work	Job to schedule

Returns

common::VoidResult Success or error

Implements kcenon::thread::scheduler_interface.

Definition at line 48 of file adaptive_job_queue.cpp.

                                                                               {
    return enqueue(std::move(work));
}

size()

auto kcenon::thread::adaptive_job_queue::size ( ) const -> std::size_t

nodiscard

Returns the current number of jobs in the queue.

Returns

Number of pending jobs

Note

Exact in mutex mode, approximate in lock-free mode

Definition at line 150 of file adaptive_job_queue.cpp.

                                                 {
    mode current = current_mode_.load(std::memory_order_acquire);
 
    if (current == mode::mutex) {
        return mutex_queue_->size();
    } else {
        return lockfree_queue_->size();
    }
}

References current_mode_, lockfree_queue_, mutex, and mutex_queue_.

stop()

auto kcenon::thread::adaptive_job_queue::stop

(

)

-> void

Signals the queue to stop.

Definition at line 174 of file adaptive_job_queue.cpp.

                                      {
    stopped_.store(true, std::memory_order_release);
    mutex_queue_->stop();
}

Referenced by ~adaptive_job_queue().

Here is the caller graph for this function:

switch_mode()

auto kcenon::thread::adaptive_job_queue::switch_mode

(

mode

m

)

-> common::VoidResult

Manually switch mode (only if policy is manual)

Parameters

m	Target mode to switch to

Returns

common::VoidResult Success or error if policy is not manual

Definition at line 225 of file adaptive_job_queue.cpp.

                                                               {
    if (policy_ != policy::manual) {
        return common::error_info{static_cast<int>(error_code::invalid_argument),
            "Mode switching is only allowed with manual policy", "thread_system"};
    }
 
    if (current_mode_.load(std::memory_order_acquire) == m) {
        return common::ok(); // Already in target mode
    }
 
    migrate_to_mode(m);
    return common::ok();
}

References kcenon::thread::invalid_argument.

try_dequeue()

auto kcenon::thread::adaptive_job_queue::try_dequeue ( ) -> common::Result<std::unique_ptr<job>>

nodiscard

Tries to dequeue a job without blocking.

Returns

common::Result<std::unique_ptr<job>> The dequeued job or error

Definition at line 113 of file adaptive_job_queue.cpp.

                                                                         {
    if (stopped_.load(std::memory_order_acquire)) {
        return common::error_info{static_cast<int>(error_code::queue_stopped), "Queue is stopped", "thread_system"};
    }
 
    common::Result<std::unique_ptr<job>> result = common::error_info{static_cast<int>(error_code::queue_empty), "Queue is empty", "thread_system"};
    mode current = current_mode_.load(std::memory_order_acquire);
 
    // Try current mode first
    if (current == mode::mutex) {
        result = mutex_queue_->try_dequeue();
        // If current mode is empty, also check other queue for race condition handling
        if (result.is_err()) {
            result = lockfree_queue_->try_dequeue();
        }
    } else {
        result = lockfree_queue_->try_dequeue();
        // If current mode is empty, also check other queue for race condition handling
        if (result.is_err()) {
            result = mutex_queue_->try_dequeue();
        }
    }
 
    if (result.is_ok()) {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        ++stats_.dequeue_count;
    }
 
    return result;
}

References kcenon::thread::result< T >::is_ok(), kcenon::thread::queue_empty, and kcenon::thread::queue_stopped.

Here is the call graph for this function:

update_mode_time()

void kcenon::thread::adaptive_job_queue::update_mode_time ( )

private

Definition at line 376 of file adaptive_job_queue.cpp.

                                          {
    std::lock_guard<std::mutex> lock(stats_mutex_);
 
    auto now = std::chrono::steady_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
        now - mode_start_time_).count();
 
    if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
        stats_.time_in_mutex_ms += duration;
    } else {
        stats_.time_in_lockfree_ms += duration;
    }
 
    mode_start_time_ = now;
}

References current_mode_, mode_start_time_, mutex, stats_, stats_mutex_, kcenon::thread::adaptive_job_queue::stats::time_in_lockfree_ms, and kcenon::thread::adaptive_job_queue::stats::time_in_mutex_ms.

Referenced by migrate_to_mode(), and ~adaptive_job_queue().

Here is the caller graph for this function:

Member Data Documentation

accuracy_guard_count_

std::atomic<int> kcenon::thread::adaptive_job_queue::accuracy_guard_count_ {0}

private

Definition at line 324 of file adaptive_job_queue.h.

{0};

Referenced by kcenon::thread::adaptive_job_queue::accuracy_guard::accuracy_guard().

current_mode_

std::atomic<mode> kcenon::thread::adaptive_job_queue::current_mode_

private

Definition at line 313 of file adaptive_job_queue.h.

Referenced by adaptive_job_queue(), current_mode(), get_capabilities(), get_stats(), migrate_to_mode(), size(), and update_mode_time().

lockfree_queue_

std::unique_ptr<detail::lockfree_job_queue> kcenon::thread::adaptive_job_queue::lockfree_queue_

private

Definition at line 318 of file adaptive_job_queue.h.

Referenced by empty(), migrate_to_mode(), and size().

migration_mutex_

std::mutex kcenon::thread::adaptive_job_queue::migration_mutex_

mutableprivate

Definition at line 321 of file adaptive_job_queue.h.

Referenced by migrate_to_mode().

mode_start_time_

std::chrono::steady_clock::time_point kcenon::thread::adaptive_job_queue::mode_start_time_

private

Definition at line 329 of file adaptive_job_queue.h.

Referenced by get_stats(), migrate_to_mode(), and update_mode_time().

mutex_queue_

std::shared_ptr<job_queue> kcenon::thread::adaptive_job_queue::mutex_queue_

private

Definition at line 317 of file adaptive_job_queue.h.

Referenced by empty(), migrate_to_mode(), and size().

policy_

policy kcenon::thread::adaptive_job_queue::policy_

private

Definition at line 312 of file adaptive_job_queue.h.

Referenced by adaptive_job_queue(), and current_policy().

stats_

stats kcenon::thread::adaptive_job_queue::stats_

private

Definition at line 328 of file adaptive_job_queue.h.

Referenced by determine_mode_for_balanced(), get_stats(), migrate_to_mode(), and update_mode_time().

stats_mutex_

std::mutex kcenon::thread::adaptive_job_queue::stats_mutex_

mutableprivate

Definition at line 327 of file adaptive_job_queue.h.

Referenced by determine_mode_for_balanced(), get_stats(), migrate_to_mode(), and update_mode_time().

stopped_

std::atomic<bool> kcenon::thread::adaptive_job_queue::stopped_ {false}

private

Definition at line 314 of file adaptive_job_queue.h.

{false};

Referenced by is_stopped().

---

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

• include/kcenon/thread/queue/adaptive_job_queue.h
• src/queue/adaptive_job_queue.cpp