atomic.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_ASYNC_ATOMIC_HPP__
#define MSTL_CORE_ASYNC_ATOMIC_HPP__

 
#include "atomic_base.hpp"
MSTL_BEGIN_NAMESPACE__

 
template <typename T>
struct atomic;
 
#define __MSTL_ATOMIC_CONSTRUCTIONS \
    atomic() = default; \
    ~atomic() noexcept = default; \
    atomic(const atomic&) = delete; \
    atomic& operator =(const atomic&) = delete; \
    atomic& operator =(const atomic&) volatile = delete; \
    atomic(atomic&&) noexcept = default; \
    atomic& operator =(atomic&&) noexcept = default;

template <typename T>
struct atomic {
    using value_type = T;   
 
private:
    static constexpr int min_align = (sizeof(T) & (sizeof(T) - 1)) || sizeof(T) > 16 ? 0 : sizeof(T);
    static constexpr int align_inner = min_align > alignof(T) ? min_align : alignof(T);
 
    alignas(align_inner) T value_;   
 
    static_assert(is_trivially_copyable_v<T>, "atomic requires a trivially copyable type");
    static_assert(sizeof(T) > 0, "Incomplete or zero-sized types are not supported");
    static_assert(is_copy_constructible_v<T>, "atomic need copy constructible T");
    static_assert(is_move_constructible_v<T>, "atomic need move constructible T");
    static_assert(is_copy_assignable_v<T>, "atomic copy move assignable T");
    static_assert(is_move_assignable_v<T>, "atomic need move assignable T");
 
public:
    static constexpr bool is_always_lock_free = _MSTL is_always_lock_free<sizeof(value_), align_inner>();
 
    __MSTL_ATOMIC_CONSTRUCTIONS

    constexpr atomic(T value) noexcept
    : value_(value) {}

    operator T() const noexcept {
        return load();
    }

    operator T() const volatile noexcept {
        return load();
    }

    T operator =(T value) noexcept {
        atomic::store(value);
        return value;
    }

    T operator =(T value) volatile noexcept {
        atomic::store(value);
        return value;
    }

    bool is_lock_free() const noexcept {
        return is_always_lock_free;
    }

    bool is_lock_free() const volatile noexcept {
        return is_always_lock_free;
    }

    void store(T value, const memory_order mo = memory_order_seq_cst) noexcept {
        _MSTL atomic_store_any(_MSTL addressof(value_), value, mo);
    }

    void store(T value, const memory_order mo = memory_order_seq_cst) volatile noexcept {
        _MSTL atomic_store_any(_MSTL addressof(value_), value, mo);
    }

    T load(const memory_order mo = memory_order_seq_cst) const noexcept {
        return _MSTL atomic_load_any(_MSTL addressof(value_), mo);
    }

    T load(const memory_order mo = memory_order_seq_cst) const volatile noexcept {
        return _MSTL atomic_load_any(_MSTL addressof(value_), mo);
    }

    T exchange(T value, const memory_order mo = memory_order_seq_cst) noexcept {
        return _MSTL atomic_exchange_any(_MSTL addressof(value_), value, mo);
    }

    T exchange(T value, const memory_order mo = memory_order_seq_cst) volatile noexcept {
        return _MSTL atomic_exchange_any(_MSTL addressof(value_), value, mo);
    }

    bool compare_exchange_weak(T& expected, T desired,
        const memory_order success, const memory_order failure) noexcept {
        MSTL_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));
        return _MSTL atomic_cmpexch_weak_any(_MSTL addressof(value_), &expected, &desired, success, failure);
    }

    bool compare_exchange_weak(T& expected, T desired,
        const memory_order success, const memory_order failure) volatile noexcept {
        MSTL_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));
        return _MSTL atomic_cmpexch_weak_any(_MSTL addressof(value_), &expected, &desired, success, failure);
    }

    bool compare_exchange_weak(T& expected, T desired,
        const memory_order mo = memory_order_seq_cst) noexcept {
        return atomic::compare_exchange_weak(expected, desired, mo, cmpexch_failure_order(mo));
    }

    bool compare_exchange_weak(T& expected, T desired,
        const memory_order mo = memory_order_seq_cst) volatile noexcept {
        return atomic::compare_exchange_weak(expected, desired, mo, cmpexch_failure_order(mo));
    }

    bool compare_exchange_strong(T& expected, T desired,
        const memory_order success, const memory_order failure) noexcept {
        MSTL_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));
        return _MSTL atomic_cmpexch_strong_any(
            _MSTL addressof(value_), _MSTL addressof(expected),
            _MSTL addressof(desired), success, failure);
    }

    bool compare_exchange_strong(T& expected, T desired,
        const memory_order success, const memory_order failure) volatile noexcept {
        MSTL_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));
        return _MSTL atomic_cmpexch_strong_any(
            _MSTL addressof(value_), _MSTL addressof(expected),
            _MSTL addressof(desired), success, failure);
    }

    bool compare_exchange_strong(T& expected, T value,
        const memory_order mo = memory_order_seq_cst) noexcept {
        return atomic::compare_exchange_strong(expected, value, mo, cmpexch_failure_order(mo));
    }

    bool compare_exchange_strong(T& expected, T value,
        const memory_order mo = memory_order_seq_cst) volatile noexcept {
        return atomic::compare_exchange_strong(expected, value, mo, cmpexch_failure_order(mo));
    }
};

template <typename T>
struct atomic<T*> : atomic_base<T*> {
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    explicit atomic(T* value) noexcept : atomic_base<T*>(value) {}
 
    using atomic_base<T*>::operator =;
};

template <typename T>
struct atomic<T&> : atomic_ref_base<T> {
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    explicit atomic(T& value) noexcept : atomic_ref_base<T>(value) {}
 
    using atomic_ref_base<T>::operator =;
};
 

template <>
struct atomic<bool> {
    using value_type = bool;  
 
private:
    atomic_base<bool> base_;  
 
public:
    static constexpr bool is_always_lock_free = true;
 
    __MSTL_ATOMIC_CONSTRUCTIONS

    constexpr atomic(const bool value) noexcept
    : base_(value) {}

    bool operator =(const bool value) noexcept {
        return base_.operator =(value);
    }

    bool operator =(const bool value) volatile noexcept {
        return base_.operator =(value);
    }

    operator bool() const noexcept {
        return base_.load();
    }

    operator bool() const volatile noexcept {
        return base_.load();
    }

    bool is_lock_free() const noexcept {
        return base_.is_lock_free();
    }

    bool is_lock_free() const volatile noexcept {
        return base_.is_lock_free();
    }

    void store(const bool value, const memory_order mo = memory_order_seq_cst) noexcept {
        base_.store(value, mo);
    }

    void store(const bool value, const memory_order mo = memory_order_seq_cst) volatile noexcept {
        base_.store(value, mo);
    }

    bool load(const memory_order mo = memory_order_seq_cst) const noexcept {
        return base_.load(mo);
    }

    bool load(const memory_order mo = memory_order_seq_cst) const volatile noexcept {
        return base_.load(mo);
    }

    bool exchange(const bool value, const memory_order mo = memory_order_seq_cst) noexcept {
        return base_.exchange(value, mo);
    }

    bool exchange(const bool value, const memory_order mo = memory_order_seq_cst) volatile noexcept {
        return base_.exchange(value, mo);
    }

    bool compare_exchange_weak(bool& value1, const bool value2,
        const memory_order success, const memory_order failure) noexcept {
        return base_.compare_exchange_weak(value1, value2, success, failure);
    }

    bool compare_exchange_weak(bool& value1, const bool value2,
        const memory_order success, const memory_order failure) volatile noexcept {
        return base_.compare_exchange_weak(value1, value2, success, failure);
    }

    bool compare_exchange_weak(bool& value1, const bool value2,
        const memory_order mo = memory_order_seq_cst) noexcept {
        return base_.compare_exchange_weak(value1, value2, mo);
    }

    bool compare_exchange_weak(bool& value1, const bool value2,
        const memory_order mo = memory_order_seq_cst) volatile noexcept {
        return base_.compare_exchange_weak(value1, value2, mo);
    }

    bool compare_exchange_strong(bool& value1, const bool value2,
        const memory_order success, const memory_order failure) noexcept {
        return base_.compare_exchange_strong(value1, value2, success, failure);
    }

    bool compare_exchange_strong(bool& value1, const bool value2,
        const memory_order success, const memory_order failure) volatile noexcept {
        return base_.compare_exchange_strong(value1, value2, success, failure);
    }

    bool compare_exchange_strong(bool& value1, const bool value2,
        const memory_order mo = memory_order_seq_cst) noexcept {
        return base_.compare_exchange_strong(value1, value2, mo);
    }

    bool compare_exchange_strong(bool& value1, const bool value2,
        const memory_order mo = memory_order_seq_cst) volatile noexcept {
        return base_.compare_exchange_strong(value1, value2, mo);
    }

    void wait(const bool old, const memory_order mo = memory_order_seq_cst) const noexcept {
        base_.wait(old, mo);
    }

    void notify_one() noexcept {
        base_.notify_one();
    }

    void notify_all() noexcept {
        base_.notify_all();
    }
};

template <>
struct atomic<char> : atomic_base<char> {
    using integral_type = char;
    using base_type = atomic_base<char>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<signed char> : atomic_base<signed char> {
    using integral_type = signed char;
    using base_type = atomic_base<signed char>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<unsigned char> : atomic_base<unsigned char> {
    using integral_type = unsigned char;
    using base_type = atomic_base<unsigned char>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<short> : atomic_base<short> {
    using integral_type = short;
    using base_type = atomic_base<short>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<unsigned short> : atomic_base<unsigned short> {
    using integral_type = unsigned short;
    using base_type = atomic_base<unsigned short>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<int> : atomic_base<int> {
    using integral_type = int;
    using base_type = atomic_base<int>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<unsigned int> : atomic_base<unsigned int> {
    using integral_type = unsigned int;
    using base_type = atomic_base<unsigned int>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<long> : atomic_base<long> {
    using integral_type = long;
    using base_type = atomic_base<long>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<unsigned long> : atomic_base<unsigned long> {
    using integral_type = unsigned long;
    using base_type = atomic_base<unsigned long>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<long long> : atomic_base<long long> {
    using integral_type = long long;
    using base_type = atomic_base<long long>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<unsigned long long> : atomic_base<unsigned long long> {
    using integral_type = unsigned long long;
    using base_type = atomic_base<unsigned long long>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<wchar_t> : atomic_base<wchar_t> {
    using integral_type = wchar_t;
    using base_type = atomic_base<wchar_t>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};
 
#ifdef MSTL_STANDARD_20__
template <>
struct atomic<char8_t> : atomic_base<char8_t> {
    using integral_type = char8_t;
    using base_type = atomic_base<char8_t>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};
#endif

template <>
struct atomic<char16_t> : atomic_base<char16_t> {
    using integral_type = char16_t;
    using base_type = atomic_base<char16_t>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<char32_t> : atomic_base<char32_t> {
    using integral_type = char32_t;
    using base_type = atomic_base<char32_t>;
 
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const integral_type value) noexcept : base_type(value) {}
 
    using base_type::operator integral_type;
    using base_type::operator =;
 
    static constexpr bool is_always_lock_free = true;
};

template <>
struct atomic<float> : atomic_float_base<float> {
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const float value) noexcept
    : atomic_float_base<float>(value) {}
 
    using atomic_float_base<float>::operator =;
};

template <>
struct atomic<double> : atomic_float_base<double> {
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const double value) noexcept
    : atomic_float_base<double>(value) {}
 
    using atomic_float_base<double>::operator =;
};

template <>
struct atomic<long double> : atomic_float_base<long double> {
    __MSTL_ATOMIC_CONSTRUCTIONS
 
    constexpr atomic(const long double value) noexcept
    : atomic_float_base<long double>(value) {}
 
    using atomic_float_base<long double>::operator =;
};
 
#undef __MSTL_ATOMIC_CONSTRUCTIONS
 
using atomic_bool     = atomic<bool>;           
using atomic_schar    = atomic<signed char>;    
using atomic_uchar    = atomic<unsigned char>;  
using atomic_short    = atomic<short>;          
using atomic_ushort   = atomic<unsigned short>; 
using atomic_int      = atomic<int>;            
using atomic_uint     = atomic<unsigned int>;   
using atomic_long     = atomic<long>;           
using atomic_ulong    = atomic<unsigned long>;  
using atomic_llong    = atomic<long long>;      
using atomic_ullong   = atomic<unsigned long long>; 
 
using atomic_float    = atomic<float>;       
using atomic_double   = atomic<double>;      
using atomic_ldouble  = atomic<long double>; 
 
using atomic_char     = atomic<char>;        
using atomic_wchar_t  = atomic<wchar_t>;     
#ifdef MSTL_STANDARD_20__
using atomic_char8_t  = atomic<char8_t>;     
#endif
using atomic_char16_t = atomic<char16_t>;    
using atomic_char32_t = atomic<char32_t>;    
 
using atomic_int8_t   = atomic<int8_t>;      
using atomic_uint8_t  = atomic<uint8_t>;     
using atomic_int16_t  = atomic<int16_t>;     
using atomic_uint16_t = atomic<uint16_t>;    
using atomic_int32_t  = atomic<int32_t>;     
using atomic_uint32_t = atomic<uint32_t>;    
using atomic_int64_t  = atomic<int64_t>;     
using atomic_uint64_t = atomic<uint64_t>;    
 
using atomic_float32  = atomic<float32_t>;   
using atomic_float64  = atomic<float64_t>;   
using atomic_decimal  = atomic<decimal_t>;   
 
using atomic_intptr_t  = atomic<intptr_t>;   
using atomic_uintptr_t = atomic<uintptr_t>;  
using atomic_size_t    = atomic<size_t>;     
using atomic_ptrdiff_t = atomic<ptrdiff_t>;  
 
using atomic_intmax_t  = atomic<intmax_t>;   
using atomic_uintmax_t = atomic<uintmax_t>;  
 // AtomicOperations
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_ASYNC_ATOMIC_HPP__