vl_atomic.h

Go to the documentation of this file.

 
#ifndef VL_ATOMIC_H
#define VL_ATOMIC_H
 
#ifdef __cplusplus
#error The vl_atomic header does not work under C++ compilation due to the use of the _Atomic keyword.
#endif
 
#include <stdatomic.h>
 
#include "vl_numtypes.h"
 
#ifdef VL_ATOMIC
#undef VL_ATOMIC
#endif
 
#ifdef VL_ATOMIC_TYPEDEF
#undef VL_ATOMIC_TYPEDEF
#endif
 
#define VL_ATOMIC _Atomic
#define VL_ATOMIC_TYPEDEF(x) typedef VL_ATOMIC x
 
VL_ATOMIC_TYPEDEF(vl_bool_t) vl_atomic_bool_t;
 
VL_ATOMIC_TYPEDEF(vl_int_t) vl_atomic_int_t;
VL_ATOMIC_TYPEDEF(vl_uint_t) vl_atomic_uint_t;
 
VL_ATOMIC_TYPEDEF(vl_intptr_t) vl_atomic_intptr_t;
VL_ATOMIC_TYPEDEF(vl_uintptr_t) vl_atomic_uintptr_t;
 
VL_ATOMIC_TYPEDEF(vl_ularge_t) vl_atomic_ularge_t;
VL_ATOMIC_TYPEDEF(vl_usmall_t) vl_atomic_usmall_t;
VL_ATOMIC_TYPEDEF(vl_ilarge_t) vl_atomic_ilarge_t;
VL_ATOMIC_TYPEDEF(vl_ismall_t) vl_atomic_ismall_t;
 
#ifdef VL_U8_T
#define VL_ATOMIC_U8_T vl_atomic_uint8_t
 
VL_ATOMIC_TYPEDEF(vl_uint8_t) VL_ATOMIC_U8_T;
#endif
 
#ifdef VL_U16_T
#define VL_ATOMIC_U16_T vl_atomic_uint16_t
 
VL_ATOMIC_TYPEDEF(vl_uint16_t) VL_ATOMIC_U16_T;
#endif
 
#ifdef VL_U32_T
#define VL_ATOMIC_U32_T vl_atomic_uint32_t
 
VL_ATOMIC_TYPEDEF(vl_uint32_t) VL_ATOMIC_U32_T;
#endif
 
#ifdef VL_U64_T
#define VL_ATOMIC_U64_T vl_atomic_uint64_t
 
VL_ATOMIC_TYPEDEF(vl_uint64_t) VL_ATOMIC_U64_T;
#endif
 
#ifdef VL_I8_T
#define VL_ATOMIC_I8_T vl_atomic_int8_t
 
VL_ATOMIC_TYPEDEF(vl_int8_t) VL_ATOMIC_I8_T;
#endif
 
#ifdef VL_I16_T
#define VL_ATOMIC_I16_T vl_atomic_int16_t
 
VL_ATOMIC_TYPEDEF(vl_int16_t) VL_ATOMIC_I16_T;
#endif
 
#ifdef VL_I32_T
#define VL_ATOMIC_I32_T vl_atomic_int32_t
 
VL_ATOMIC_TYPEDEF(vl_int32_t) VL_ATOMIC_I32_T;
#endif
 
#ifdef VL_I64_T
#define VL_ATOMIC_I64_T vl_atomic_int64_t
 
VL_ATOMIC_TYPEDEF(vl_int64_t) VL_ATOMIC_I64_T;
#endif
 
VL_ATOMIC_TYPEDEF(atomic_flag) vl_atomic_flag_t;
 
typedef enum VL_MEMORY_ORDER
{
    VL_MEMORY_ORDER_RELAXED = memory_order_relaxed,
 
    VL_MEMORY_ORDER_ACQUIRE = memory_order_acquire,
 
    VL_MEMORY_ORDER_RELEASE = memory_order_release,
 
    VL_MEMORY_ORDER_ACQ_REL = memory_order_acq_rel,
 
    VL_MEMORY_ORDER_SEQ_CST = memory_order_seq_cst
} vl_memory_order_t;
 
// Load & Store Ops
 
#define vlAtomicLoad(ptr) atomic_load(ptr)
 
#define vlAtomicLoadExplicit(ptr, order) atomic_load_explicit(ptr, (memory_order)(order))
 
#define vlAtomicStore(ptr, val) atomic_store(ptr, val)
 
#define vlAtomicStoreExplicit(ptr, val, order) atomic_store_explicit(ptr, val, (memory_order)(order))
 
// Arithmetic
 
#define vlAtomicFetchAdd(ptr, arg) atomic_fetch_add(ptr, arg)
 
#define vlAtomicFetchSub(ptr, arg) atomic_fetch_sub(ptr, arg)
 
#define vlAtomicFetchOr(ptr, arg) atomic_fetch_or(ptr, arg)
 
#define vlAtomicFetchXor(ptr, arg) atomic_fetch_xor(ptr, arg)
 
#define vlAtomicFetchAnd(ptr, arg) atomic_fetch_and(ptr, arg)
 
#define vlAtomicFetchAddExplicit(ptr, arg, order) atomic_fetch_add_explicit(ptr, arg, (memory_order)(order))
 
#define vlAtomicFetchSubExplicit(ptr, arg, order) atomic_fetch_sub_explicit(ptr, arg, (memory_order)(order))
 
#define vlAtomicFetchOrExplicit(ptr, arg, order) atomic_fetch_or_explicit(ptr, arg, (memory_order)(order))
 
#define vlAtomicFetchXorExplicit(ptr, arg, order) atomic_fetch_xor_explicit(ptr, arg, (memory_order)(order))
 
#define vlAtomicFetchAndExplicit(ptr, arg, order) atomic_fetch_and_explicit(ptr, arg, (memory_order)(order))
 
// Exchange, Compare & Swap
 
#define vlAtomicExchange(ptr, desired) atomic_exchange(ptr, desired)
 
#define vlAtomicExchangeExplicit(ptr, desired, order) atomic_exchange_explicit(ptr, desired, (memory_order)(order))
 
#define vlAtomicCompareExchangeWeak(ptr, expectedPtr, desired) atomic_compare_exchange_weak(ptr, expectedPtr, desired)
 
#define vlAtomicCompareExchangeStrong(ptr, expectedPtr, desired)                                                       \
    atomic_compare_exchange_strong(ptr, expectedPtr, desired)
 
#define vlAtomicCompareExchangeWeakExplicit(ptr, expectedPtr, desired, trueOrder, falseOrder)                          \
    atomic_compare_exchange_weak_explicit(ptr, expectedPtr, desired, (memory_order)(trueOrder),                        \
                                          (memory_order)(falseOrder))
 
#define vlAtomicCompareExchangeStrongExplicit(ptr, expectedPtr, desired, trueOrder, falseOrder)                        \
    atomic_compare_exchange_strong_explicit(ptr, expectedPtr, desired, (memory_order)(trueOrder),                      \
                                            (memory_order)(falseOrder))
 
// Thread Fencing
 
#define vlAtomicThreadFence(order) atomic_thread_fence((memory_order)(order))
 
#define vlAtomicFlagTestAndSet(ptr) atomic_flag_test_and_set(ptr)
 
#define vlAtomicFlagClear(ptr) atomic_flag_clear(ptr)
 
#define vlAtomicFlagTestAndSetExplicit(ptr, order) atomic_flag_test_and_set_explicit(ptr, (memory_order)(order))
 
#define vlAtomicFlagClearExplicit(ptr, order) atomic_flag_clear_explicit(ptr, (memory_order)(order))
 
// Init
 
#define vlAtomicInit(ptr, val) atomic_init(ptr, val)
 
#undef VL_ATOMIC_TYPEDEF
#endif // VL_ATOMIC_H