atomic.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <atomic>
#include <type_traits>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
enum class MemoryOrder {
        Relaxed,  
        Consume,  
        Acquire,  
        Release,  
        AcqRel,   
        SeqCst    
};
 
inline constexpr std::memory_order toStdMemoryOrder(MemoryOrder mo) {
        switch (mo) {
                case MemoryOrder::Relaxed: return std::memory_order_relaxed;
                case MemoryOrder::Consume: return std::memory_order_consume;
                case MemoryOrder::Acquire: return std::memory_order_acquire;
                case MemoryOrder::Release: return std::memory_order_release;
                case MemoryOrder::AcqRel:  return std::memory_order_acq_rel;
                case MemoryOrder::SeqCst:  return std::memory_order_seq_cst;
        }
        return std::memory_order_seq_cst;
}
 
inline void atomicThreadFence(MemoryOrder mo) {
        std::atomic_thread_fence(toStdMemoryOrder(mo));
}
 
template <typename T> class Atomic {
                static_assert(std::is_trivially_copyable_v<T>,
                              "Atomic<T> requires T to be trivially copyable (std::atomic requirement)");
 
        public:
                using ValueType = T;
 
                explicit Atomic() : _value(T{}) {}
 
                explicit Atomic(T val) : _value(val) {}
 
                ~Atomic() = default;
 
                Atomic(const Atomic &) = delete;
                Atomic &operator=(const Atomic &) = delete;
                Atomic(Atomic &&) = delete;
                Atomic &operator=(Atomic &&) = delete;
 
                // --------------------------------------------------------
                // Default-order accessors (preserved API).
                // --------------------------------------------------------
 
                T value() const { return _value.load(std::memory_order_acquire); }
 
                void setValue(T val) { _value.store(val, std::memory_order_release); }
 
                bool compareAndSwap(T &expected, T desired) {
                        return _value.compare_exchange_strong(expected, desired, std::memory_order_acq_rel,
                                                              std::memory_order_acquire);
                }
 
                T exchange(T desired) { return _value.exchange(desired, std::memory_order_acq_rel); }
 
                // --------------------------------------------------------
                // Explicit-order accessors.
                //
                // Defaults follow the C++ convention: SeqCst on
                // load / store / exchange / compare-exchange (the
                // strongest, safest choice when callers don't think
                // hard about it), AcqRel on read-modify-write
                // (fetch_*) since RMW with seq_cst is a meaningful
                // extra cost on most ISAs and AcqRel is what a
                // refcount-style operation actually needs.  Mirrored
                // identically by @ref AtomicRef.
                // --------------------------------------------------------
 
                T load(MemoryOrder mo = MemoryOrder::SeqCst) const {
                        return _value.load(toStdMemoryOrder(mo));
                }
 
                void store(T val, MemoryOrder mo = MemoryOrder::SeqCst) {
                        _value.store(val, toStdMemoryOrder(mo));
                }
 
                T exchange(T desired, MemoryOrder mo) {
                        return _value.exchange(desired, toStdMemoryOrder(mo));
                }
 
                T fetchAndAdd(T val, MemoryOrder mo = MemoryOrder::AcqRel) {
                        return _value.fetch_add(val, toStdMemoryOrder(mo));
                }
 
                T fetchAndSub(T val, MemoryOrder mo = MemoryOrder::AcqRel) {
                        return _value.fetch_sub(val, toStdMemoryOrder(mo));
                }
 
                T fetchAndAnd(T val, MemoryOrder mo = MemoryOrder::AcqRel) {
                        return _value.fetch_and(val, toStdMemoryOrder(mo));
                }
 
                T fetchAndOr(T val, MemoryOrder mo = MemoryOrder::AcqRel) {
                        return _value.fetch_or(val, toStdMemoryOrder(mo));
                }
 
                T fetchAndXor(T val, MemoryOrder mo = MemoryOrder::AcqRel) {
                        return _value.fetch_xor(val, toStdMemoryOrder(mo));
                }
 
                bool compareExchangeStrong(T &expected, T desired, MemoryOrder success, MemoryOrder failure) {
                        return _value.compare_exchange_strong(expected, desired, toStdMemoryOrder(success),
                                                              toStdMemoryOrder(failure));
                }
 
                bool compareExchangeStrong(T &expected, T desired, MemoryOrder mo = MemoryOrder::SeqCst) {
                        return _value.compare_exchange_strong(expected, desired, toStdMemoryOrder(mo));
                }
 
                bool compareExchangeWeak(T &expected, T desired, MemoryOrder success, MemoryOrder failure) {
                        return _value.compare_exchange_weak(expected, desired, toStdMemoryOrder(success),
                                                            toStdMemoryOrder(failure));
                }
 
                bool compareExchangeWeak(T &expected, T desired, MemoryOrder mo = MemoryOrder::SeqCst) {
                        return _value.compare_exchange_weak(expected, desired, toStdMemoryOrder(mo));
                }
 
                // --------------------------------------------------------
                // Convenience: implicit conversion to T (SeqCst load).
                // --------------------------------------------------------
 
                T operator++() { return _value.fetch_add(1, std::memory_order_acq_rel) + 1; }
 
                T operator++(int) { return _value.fetch_add(1, std::memory_order_acq_rel); }
 
                T operator--() { return _value.fetch_sub(1, std::memory_order_acq_rel) - 1; }
 
                T operator--(int) { return _value.fetch_sub(1, std::memory_order_acq_rel); }
 
        private:
                std::atomic<T> _value;
};
 
template <typename T> class AtomicRef {
                static_assert(std::is_trivially_copyable_v<T>,
                              "AtomicRef<T> requires T to be trivially copyable (std::atomic_ref requirement)");
 
        public:
                using ValueType = T;
 
                explicit AtomicRef(T &obj) : _ref(obj) {}
 
                AtomicRef(const AtomicRef &) = default;
                AtomicRef &operator=(const AtomicRef &) = delete;
                AtomicRef(AtomicRef &&) = default;
                AtomicRef &operator=(AtomicRef &&) = delete;
 
                T load(MemoryOrder mo = MemoryOrder::SeqCst) const {
                        return _ref.load(toStdMemoryOrder(mo));
                }
 
                void store(T val, MemoryOrder mo = MemoryOrder::SeqCst) const {
                        _ref.store(val, toStdMemoryOrder(mo));
                }
 
                T exchange(T desired, MemoryOrder mo = MemoryOrder::SeqCst) const {
                        return _ref.exchange(desired, toStdMemoryOrder(mo));
                }
 
                T fetchAndAdd(T val, MemoryOrder mo = MemoryOrder::AcqRel) const {
                        return _ref.fetch_add(val, toStdMemoryOrder(mo));
                }
 
                T fetchAndSub(T val, MemoryOrder mo = MemoryOrder::AcqRel) const {
                        return _ref.fetch_sub(val, toStdMemoryOrder(mo));
                }
 
                bool compareExchangeStrong(T &expected, T desired, MemoryOrder success, MemoryOrder failure) const {
                        return _ref.compare_exchange_strong(expected, desired, toStdMemoryOrder(success),
                                                            toStdMemoryOrder(failure));
                }
 
                bool compareExchangeStrong(T &expected, T desired, MemoryOrder mo = MemoryOrder::SeqCst) const {
                        return _ref.compare_exchange_strong(expected, desired, toStdMemoryOrder(mo));
                }
 
                bool compareExchangeWeak(T &expected, T desired, MemoryOrder success, MemoryOrder failure) const {
                        return _ref.compare_exchange_weak(expected, desired, toStdMemoryOrder(success),
                                                          toStdMemoryOrder(failure));
                }
 
                bool compareExchangeWeak(T &expected, T desired, MemoryOrder mo = MemoryOrder::SeqCst) const {
                        return _ref.compare_exchange_weak(expected, desired, toStdMemoryOrder(mo));
                }
 
        private:
                std::atomic_ref<T> _ref;
};
 
class AtomicFlag {
        public:
                AtomicFlag() noexcept = default;
 
                ~AtomicFlag() = default;
 
                AtomicFlag(const AtomicFlag &) = delete;
                AtomicFlag &operator=(const AtomicFlag &) = delete;
                AtomicFlag(AtomicFlag &&) = delete;
                AtomicFlag &operator=(AtomicFlag &&) = delete;
 
                bool testAndSet(MemoryOrder mo = MemoryOrder::Acquire) noexcept {
                        return _flag.test_and_set(toStdMemoryOrder(mo));
                }
 
                void clear(MemoryOrder mo = MemoryOrder::Release) noexcept {
                        _flag.clear(toStdMemoryOrder(mo));
                }
 
                bool test(MemoryOrder mo = MemoryOrder::Acquire) const noexcept {
                        return _flag.test(toStdMemoryOrder(mo));
                }
 
        private:
                std::atomic_flag _flag = ATOMIC_FLAG_INIT;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE