kcenon::thread::policies::adaptive_sync_policy Class Reference

Adaptive synchronization policy that can switch modes. More...

#include <sync_policies.h>

Collaboration diagram for kcenon::thread::policies::adaptive_sync_policy:

Public Types
enum class	mode { mutex , lock_free }
	Operating mode. More...
using	policy_tag = sync_policy_tag

Public Member Functions
auto	get_capabilities () const -> queue_capabilities
	Queue capabilities (dynamic based on mode)
	adaptive_sync_policy (mode initial_mode=mode::mutex)
	Construct adaptive sync policy.
	~adaptive_sync_policy ()=default
	Destructor.
	adaptive_sync_policy (const adaptive_sync_policy &)=delete
adaptive_sync_policy &	operator= (const adaptive_sync_policy &)=delete
	adaptive_sync_policy (adaptive_sync_policy &&)=delete
adaptive_sync_policy &	operator= (adaptive_sync_policy &&)=delete
auto	enqueue (std::unique_ptr< job > &&value) -> common::VoidResult
	Enqueue a job.
auto	dequeue () -> common::Result< std::unique_ptr< job > >
	Dequeue a job.
auto	try_dequeue () -> common::Result< std::unique_ptr< job > >
	Try to dequeue a job.
auto	empty () const -> bool
	Check if queue is empty.
auto	size () const -> std::size_t
	Get queue size.
auto	clear () -> void
	Clear queue.
auto	stop () -> void
	Stop queue.
auto	is_stopped () const -> bool
	Check if stopped.
auto	set_notify (bool notify) -> void
	Set notify flag.
auto	current_mode () const -> mode
	Get current mode.
auto	switch_mode (mode target_mode) -> void
	Switch to a different mode.

Private Attributes
std::atomic< mode >	current_mode_
std::unique_ptr< mutex_sync_policy >	mutex_policy_
std::unique_ptr< lockfree_sync_policy >	lockfree_policy_

Detailed Description

Adaptive synchronization policy that can switch modes.

Wraps both mutex and lock-free policies and can switch between them based on runtime requirements.

Thread Safety

• All operations are thread-safe
• Mode switching is synchronized

Definition at line 421 of file sync_policies.h.

Member Typedef Documentation

policy_tag

using kcenon::thread::policies::adaptive_sync_policy::policy_tag = sync_policy_tag

Definition at line 423 of file sync_policies.h.

Member Enumeration Documentation

mode

enum class kcenon::thread::policies::adaptive_sync_policy::mode

strong

Operating mode.

Enumerator
mutex	Using mutex sync.
lock_free	Using lock-free sync.

Definition at line 428 of file sync_policies.h.

                    {
        mutex,     
        lock_free  
    };

Constructor & Destructor Documentation

adaptive_sync_policy() [1/3]

kcenon::thread::policies::adaptive_sync_policy::adaptive_sync_policy ( mode initial_mode = mode::mutex )

inlineexplicit

Construct adaptive sync policy.

Parameters

initial_mode

Initial operating mode

Definition at line 447 of file sync_policies.h.

        : current_mode_(initial_mode)
        , mutex_policy_(std::make_unique<mutex_sync_policy>())
        , lockfree_policy_(std::make_unique<lockfree_sync_policy>()) {}

~adaptive_sync_policy()

kcenon::thread::policies::adaptive_sync_policy::~adaptive_sync_policy ( )

default

Destructor.

adaptive_sync_policy() [2/3]

kcenon::thread::policies::adaptive_sync_policy::adaptive_sync_policy ( const adaptive_sync_policy & )

delete

adaptive_sync_policy() [3/3]

kcenon::thread::policies::adaptive_sync_policy::adaptive_sync_policy ( adaptive_sync_policy && )

delete

Member Function Documentation

clear()

auto kcenon::thread::policies::adaptive_sync_policy::clear ( ) -> void

inline

Clear queue.

Definition at line 522 of file sync_policies.h.

                         {
        if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
            mutex_policy_->clear();
        } else {
            lockfree_policy_->clear();
        }
    }

References current_mode_, lockfree_policy_, mutex, and mutex_policy_.

current_mode()

auto kcenon::thread::policies::adaptive_sync_policy::current_mode ( ) const -> mode

inlinenodiscard

Get current mode.

Returns

Current operating mode

Definition at line 561 of file sync_policies.h.

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

References current_mode_.

dequeue()

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

inlinenodiscard

Dequeue a job.

Returns

Result containing the job or error

Definition at line 479 of file sync_policies.h.

                                                                     {
        if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
            return mutex_policy_->dequeue();
        }
        return lockfree_policy_->dequeue();
    }

References current_mode_, lockfree_policy_, mutex, and mutex_policy_.

empty()

auto kcenon::thread::policies::adaptive_sync_policy::empty ( ) const -> bool

inlinenodiscard

Check if queue is empty.

Returns

true if empty

Definition at line 501 of file sync_policies.h.

                                             {
        if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
            return mutex_policy_->empty();
        }
        return lockfree_policy_->empty();
    }

References current_mode_, lockfree_policy_, mutex, and mutex_policy_.

enqueue()

auto kcenon::thread::policies::adaptive_sync_policy::enqueue ( std::unique_ptr< job > && value ) -> common::VoidResult

inlinenodiscard

Enqueue a job.

Parameters

value

Job to enqueue

Returns

VoidResult indicating success or error

Definition at line 468 of file sync_policies.h.

                                                                               {
        if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
            return mutex_policy_->enqueue(std::move(value));
        }
        return lockfree_policy_->enqueue(std::move(value));
    }

References current_mode_, lockfree_policy_, mutex, and mutex_policy_.

get_capabilities()

auto kcenon::thread::policies::adaptive_sync_policy::get_capabilities ( ) const -> queue_capabilities

inlinenodiscard

Queue capabilities (dynamic based on mode)

Definition at line 436 of file sync_policies.h.

                                                                      {
        if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
            return mutex_sync_policy::get_capabilities();
        }
        return lockfree_sync_policy::get_capabilities();
    }

References current_mode_, kcenon::thread::policies::lockfree_sync_policy::get_capabilities(), kcenon::thread::policies::mutex_sync_policy::get_capabilities(), and mutex.

Here is the call graph for this function:

is_stopped()

auto kcenon::thread::policies::adaptive_sync_policy::is_stopped ( ) const -> bool

inlinenodiscard

Check if stopped.

Returns

true if stopped

Definition at line 542 of file sync_policies.h.

                                                  {
        if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
            return mutex_policy_->is_stopped();
        }
        return lockfree_policy_->is_stopped();
    }

References current_mode_, lockfree_policy_, mutex, and mutex_policy_.

operator=() [1/2]

adaptive_sync_policy & kcenon::thread::policies::adaptive_sync_policy::operator= ( adaptive_sync_policy && )

delete

operator=() [2/2]

adaptive_sync_policy & kcenon::thread::policies::adaptive_sync_policy::operator= ( const adaptive_sync_policy & )

delete

set_notify()

auto kcenon::thread::policies::adaptive_sync_policy::set_notify ( bool notify ) -> void

inline

Set notify flag.

Parameters

notify

Whether to notify on enqueue

Definition at line 553 of file sync_policies.h.

                                         {
        mutex_policy_->set_notify(notify);
    }

References mutex_policy_.

size()

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

inlinenodiscard

Get queue size.

Returns

Number of jobs (exact in mutex mode, approximate in lock-free)

Definition at line 512 of file sync_policies.h.

                                                 {
        if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
            return mutex_policy_->size();
        }
        return lockfree_policy_->size();
    }

References current_mode_, lockfree_policy_, mutex, and mutex_policy_.

stop()

auto kcenon::thread::policies::adaptive_sync_policy::stop ( ) -> void

inline

Stop queue.

Definition at line 533 of file sync_policies.h.

                        {
        mutex_policy_->stop();
        lockfree_policy_->stop();
    }

References lockfree_policy_, and mutex_policy_.

switch_mode()

auto kcenon::thread::policies::adaptive_sync_policy::switch_mode ( mode target_mode ) -> void

inline

Switch to a different mode.

Parameters

target_mode

Target mode to switch to

Note

Data migration is NOT performed - caller is responsible

Definition at line 571 of file sync_policies.h.

                                               {
        current_mode_.store(target_mode, std::memory_order_release);
    }

References current_mode_.

try_dequeue()

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

inlinenodiscard

Try to dequeue a job.

Returns

Result containing the job or error

Definition at line 490 of file sync_policies.h.

                                                                         {
        if (current_mode_.load(std::memory_order_acquire) == mode::mutex) {
            return mutex_policy_->try_dequeue();
        }
        return lockfree_policy_->try_dequeue();
    }

References current_mode_, lockfree_policy_, mutex, and mutex_policy_.

Member Data Documentation

current_mode_

std::atomic<mode> kcenon::thread::policies::adaptive_sync_policy::current_mode_

private

Definition at line 576 of file sync_policies.h.

Referenced by clear(), current_mode(), dequeue(), empty(), enqueue(), get_capabilities(), is_stopped(), size(), switch_mode(), and try_dequeue().

lockfree_policy_

std::unique_ptr<lockfree_sync_policy> kcenon::thread::policies::adaptive_sync_policy::lockfree_policy_

private

Definition at line 578 of file sync_policies.h.

Referenced by clear(), dequeue(), empty(), enqueue(), is_stopped(), size(), stop(), and try_dequeue().

mutex_policy_

std::unique_ptr<mutex_sync_policy> kcenon::thread::policies::adaptive_sync_policy::mutex_policy_

private

Definition at line 577 of file sync_policies.h.

Referenced by clear(), dequeue(), empty(), enqueue(), is_stopped(), set_notify(), size(), stop(), and try_dequeue().

---

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

• include/kcenon/thread/policies/sync_policies.h