rcu_value.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <memory>
#include <type_traits>
 
namespace kcenon::container
{
    template<typename T>
    class rcu_value
    {
    public:
        static_assert(std::is_copy_constructible_v<T> || std::is_move_constructible_v<T>,
                     "T must be copy or move constructible");
 
        rcu_value() requires std::is_default_constructible_v<T>
            : current_(std::make_shared<const T>()) {}
 
        explicit rcu_value(T initial)
            : current_(std::make_shared<const T>(std::move(initial))) {}
 
        rcu_value(const rcu_value& other)
            : current_(std::atomic_load_explicit(&other.current_, std::memory_order_acquire)) {}
 
        rcu_value(rcu_value&& other) noexcept
            : current_(std::atomic_load_explicit(&other.current_, std::memory_order_acquire)) {}
 
        rcu_value& operator=(const rcu_value& other) {
            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;
        }
 
        rcu_value& operator=(rcu_value&& other) noexcept {
            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;
        }
 
        ~rcu_value() = default;
 
        [[nodiscard]] std::shared_ptr<const T> read() const noexcept {
            return std::atomic_load_explicit(&current_, std::memory_order_acquire);
        }
 
        void update(T new_value) {
            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);
        }
 
        bool compare_and_update(const std::shared_ptr<const T>& expected, T new_value) {
            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;
        }
 
        [[nodiscard]] size_t update_count() const noexcept {
            return update_count_.load(std::memory_order_relaxed);
        }
 
        [[nodiscard]] bool has_value() const noexcept {
            return std::atomic_load_explicit(&current_, std::memory_order_acquire) != nullptr;
        }
 
    private:
        std::shared_ptr<const T> current_;
        std::atomic<size_t> update_count_{0};
    };
 
} // namespace kcenon::container