memory_order.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_MEMORY_ORDER_HPP__
#define NEFORCE_CORE_ASYNC_MEMORY_ORDER_HPP__

 
#include "NeForce/core/typeinfo/types.hpp"
NEFORCE_BEGIN_NAMESPACE__



enum class memory_order : int32_t {
    relaxed, 
    consume, 
    acquire, 
    release, 
    acq_rel, 
    seq_cst  
};

NEFORCE_INLINE17 constexpr auto memory_order_relaxed = memory_order::relaxed;
NEFORCE_INLINE17 constexpr auto memory_order_consume = memory_order::consume;
NEFORCE_INLINE17 constexpr auto memory_order_acquire = memory_order::acquire;
NEFORCE_INLINE17 constexpr auto memory_order_release = memory_order::release;
NEFORCE_INLINE17 constexpr auto memory_order_acq_rel = memory_order::acq_rel;
NEFORCE_INLINE17 constexpr auto memory_order_seq_cst = memory_order::seq_cst;
 
 
#if defined(NEFORCE_ARCH_X86) && defined(NEFORCE_USING_INTEL_TSX)

enum class memory_order_modifier : int64_t {
    memory_order_none = 0,                   
    memory_order_mask = 0x0000ffff,          
    memory_order_modifier_mask = 0xffff0000, 
    memory_order_hle_acquire = 0x10000,      
    memory_order_hle_release = 0x20000,      
    memory_order_rtm_begin = 0x40000,        
    memory_order_rtm_end = 0x80000,          
    memory_order_rtm_abort = 0x100000        
};

constexpr memory_order operator|(memory_order mo, memory_order_modifier mod) noexcept {
    return static_cast<memory_order>(static_cast<int64_t>(mo) | static_cast<int64_t>(mod));
}

constexpr memory_order operator&(memory_order mo, memory_order_modifier mod) noexcept {
    return static_cast<memory_order>(static_cast<int64_t>(mo) & static_cast<int64_t>(mod));
}
 

enum class rtm_status_flag : uint32_t {
    xabort_explicit = 1 << 0, 
    retry_possible = 1 << 1,  
    memory_conflict = 1 << 2, 
    buffer_overflow = 1 << 3, 
    debug_hit = 1 << 4,       
    nested_abort = 1 << 5     
};
 
#endif
 

constexpr memory_order cmpexch_failure_order(const memory_order mo) noexcept {
#ifdef NEFORCE_SUPPORT_INTEL_TSX
    constexpr auto mask = memory_order_modifier::memory_order_mask;
    const memory_order base_mo = mo & mask;
    const memory_order failure_order = base_mo == memory_order_acq_rel   ? memory_order_acquire
                                       : base_mo == memory_order_release ? memory_order_relaxed
                                                                         : base_mo;
    constexpr auto modifier_mask = memory_order_modifier::memory_order_modifier_mask;
    const auto modifiers = static_cast<memory_order_modifier>(mo & modifier_mask);
    return failure_order | modifiers;
#else
    const memory_order failure_order = mo == memory_order_acq_rel   ? memory_order_acquire
                                       : mo == memory_order_release ? memory_order_relaxed
                                                                    : mo;
    return failure_order;
#endif
}

constexpr bool is_valid_cmpexch_failure_order(const memory_order mo) noexcept {
#ifdef NEFORCE_SUPPORT_INTEL_TSX
    return (mo & memory_order_modifier::memory_order_mask) != memory_order_release &&
           (mo & memory_order_modifier::memory_order_mask) != memory_order_acq_rel;
#else
    return mo != memory_order_release && mo != memory_order_acq_rel;
#endif
}
 // MemoryOrder
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_MEMORY_ORDER_HPP__