kcenon::container::rcu_value< T > Class Template Reference

Lock-free value wrapper using Read-Copy-Update (RCU) pattern. More...

#include <rcu_value.h>

Collaboration diagram for kcenon::container::rcu_value< T >:

Public Member Functions
	rcu_value ()
	Default constructor - initializes with default-constructed T.
	rcu_value (T initial)
	Construct with initial value.
	rcu_value (const rcu_value &other)
	Copy constructor.
	rcu_value (rcu_value &&other) noexcept
	Move constructor.
rcu_value &	operator= (const rcu_value &other)
	Copy assignment operator.
rcu_value &	operator= (rcu_value &&other) noexcept
	Move assignment operator.
	~rcu_value ()=default
	Destructor.
std::shared_ptr< const T >	read () const noexcept
	Lock-free read - returns current snapshot.
void	update (T new_value)
	Update the value atomically.
bool	compare_and_update (const std::shared_ptr< const T > &expected, T new_value)
	Compare-and-swap update.
size_t	update_count () const noexcept
	Get the number of updates performed.
bool	has_value () const noexcept
	Check if the value has been initialized.

Private Attributes
std::shared_ptr< const T >	current_
std::atomic< size_t >	update_count_ {0}

Detailed Description

template<typename T>
class kcenon::container::rcu_value< T >

Lock-free value wrapper using Read-Copy-Update (RCU) pattern.

This template provides truly lock-free reads using atomic shared_ptr operations. Writers create new versions, and readers access the current version atomically. Old versions are automatically reclaimed when the last reader releases them.

Properties:

• Read: Wait-free O(1) - no blocking, no spinning
• Update: Lock-free - may require retry under contention
• Memory: Automatic reclamation via shared_ptr reference counting

Template Parameters

T	The value type to store (must be copy-constructible or move-constructible)

Example usage:

rcu_value<int> counter{0};
 
// Lock-free read from any thread
auto snapshot = counter.read();
int value = *snapshot;
 
// Update from any thread
counter.update(42);

Definition at line 40 of file rcu_value.h.

Constructor & Destructor Documentation

rcu_value() [1/4]

template<typename T >

kcenon::container::rcu_value< T >::rcu_value ( )

inline

Default constructor - initializes with default-constructed T.

Definition at line 49 of file rcu_value.h.

            : current_(std::make_shared<const T>()) {}

rcu_value() [2/4]

template<typename T >

kcenon::container::rcu_value< T >::rcu_value ( T initial )

inlineexplicit

Construct with initial value.

Parameters

initial

The initial value

Definition at line 56 of file rcu_value.h.

            : current_(std::make_shared<const T>(std::move(initial))) {}

rcu_value() [3/4]

template<typename T >

kcenon::container::rcu_value< T >::rcu_value ( const rcu_value< T > & other )

inline

Copy constructor.

Parameters

other

The rcu_value to copy from

Definition at line 63 of file rcu_value.h.

            : current_(std::atomic_load_explicit(&other.current_, std::memory_order_acquire)) {}

rcu_value() [4/4]

template<typename T >

kcenon::container::rcu_value< T >::rcu_value ( rcu_value< T > && other )

inlinenoexcept

Move constructor.

Parameters

other

The rcu_value to move from

Definition at line 70 of file rcu_value.h.

            : current_(std::atomic_load_explicit(&other.current_, std::memory_order_acquire)) {}

~rcu_value()

template<typename T >

kcenon::container::rcu_value< T >::~rcu_value ( )

default

Destructor.

Member Function Documentation

compare_and_update()

template<typename T >

bool kcenon::container::rcu_value< T >::compare_and_update ( const std::shared_ptr< const T > & expected, T new_value )

inline

Compare-and-swap update.

Atomically updates the value only if the current value equals expected. This is useful for implementing lock-free algorithms that need to detect concurrent modifications.

Parameters

expected	Shared pointer to expected current value
new_value	The new value to store if current matches expected

Returns

true if update succeeded, false if current value changed

Thread safety: Safe to call concurrently with any other operation

Definition at line 148 of file rcu_value.h.

                                                                                     {
            auto new_ptr = std::make_shared<const T>(std::move(new_value));
            auto expected_copy = expected;
            bool success = std::atomic_compare_exchange_strong_explicit(
                &current_,
                &expected_copy,
                new_ptr,
                std::memory_order_acq_rel,
                std::memory_order_acquire
            );
            if (success) {
                update_count_.fetch_add(1, std::memory_order_relaxed);
            }
            return success;
        }

References kcenon::container::rcu_value< T >::current_, and kcenon::container::rcu_value< T >::update_count_.

has_value()

template<typename T >

bool kcenon::container::rcu_value< T >::has_value ( ) const

inlinenodiscardnoexcept

Check if the value has been initialized.

Returns

true if a value is stored, false if null

Definition at line 176 of file rcu_value.h.

                                                      {
            return std::atomic_load_explicit(&current_, std::memory_order_acquire) != nullptr;
        }

References kcenon::container::rcu_value< T >::current_.

operator=() [1/2]

template<typename T >

rcu_value & kcenon::container::rcu_value< T >::operator= ( const rcu_value< T > & other )

inline

Copy assignment operator.

Parameters

other

The rcu_value to copy from

Returns

Reference to this

Definition at line 78 of file rcu_value.h.

                                                     {
            if (this != &other) {
                auto new_ptr = std::atomic_load_explicit(&other.current_, std::memory_order_acquire);
                std::atomic_store_explicit(&current_, new_ptr, std::memory_order_release);
            }
            return *this;
        }

References kcenon::container::rcu_value< T >::current_.

operator=() [2/2]

template<typename T >

rcu_value & kcenon::container::rcu_value< T >::operator= ( rcu_value< T > && other )

inlinenoexcept

Move assignment operator.

Parameters

other

The rcu_value to move from

Returns

Reference to this

Definition at line 91 of file rcu_value.h.

                                                         {
            if (this != &other) {
                auto new_ptr = std::atomic_load_explicit(&other.current_, std::memory_order_acquire);
                std::atomic_store_explicit(&current_, new_ptr, std::memory_order_release);
            }
            return *this;
        }

References kcenon::container::rcu_value< T >::current_.

read()

template<typename T >

std::shared_ptr< const T > kcenon::container::rcu_value< T >::read ( ) const

inlinenodiscardnoexcept

Lock-free read - returns current snapshot.

This operation is wait-free: it completes in O(1) time regardless of what other threads are doing. The returned shared_ptr keeps the snapshot alive even if the value is updated by another thread.

Returns

Shared pointer to immutable snapshot of current value

Thread safety: Safe to call concurrently with any other operation

Definition at line 115 of file rcu_value.h.

                                                                   {
            return std::atomic_load_explicit(&current_, std::memory_order_acquire);
        }

References kcenon::container::rcu_value< T >::current_.

update()

template<typename T >

void kcenon::container::rcu_value< T >::update ( T new_value )

inline

Update the value atomically.

Creates a new immutable version and publishes it atomically. The old version is automatically reclaimed when the last reader releases it.

Parameters

new_value

The new value to store

Thread safety: Safe to call concurrently with any other operation

Definition at line 129 of file rcu_value.h.

                                 {
            auto new_ptr = std::make_shared<const T>(std::move(new_value));
            std::atomic_store_explicit(&current_, new_ptr, std::memory_order_release);
            update_count_.fetch_add(1, std::memory_order_relaxed);
        }

References kcenon::container::rcu_value< T >::current_, and kcenon::container::rcu_value< T >::update_count_.

update_count()

template<typename T >

size_t kcenon::container::rcu_value< T >::update_count ( ) const

inlinenodiscardnoexcept

Get the number of updates performed.

Returns

Update count since construction

Definition at line 168 of file rcu_value.h.

                                                           {
            return update_count_.load(std::memory_order_relaxed);
        }

References kcenon::container::rcu_value< T >::update_count_.

Member Data Documentation

current_

template<typename T >

std::shared_ptr<const T> kcenon::container::rcu_value< T >::current_

private

Definition at line 181 of file rcu_value.h.

Referenced by kcenon::container::rcu_value< T >::compare_and_update(), kcenon::container::rcu_value< T >::has_value(), kcenon::container::rcu_value< T >::operator=(), kcenon::container::rcu_value< T >::operator=(), kcenon::container::rcu_value< T >::read(), and kcenon::container::rcu_value< T >::update().

update_count_

template<typename T >

std::atomic<size_t> kcenon::container::rcu_value< T >::update_count_ {0}

private

Definition at line 182 of file rcu_value.h.

{0};

Referenced by kcenon::container::rcu_value< T >::compare_and_update(), kcenon::container::rcu_value< T >::update(), and kcenon::container::rcu_value< T >::update_count().

---

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

• internal/rcu_value.h