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 using 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