2015-05-01 19:34:32 +00:00
|
|
|
/* Atomics for OctaSTD. Supports GCC/Clang and possibly MSVC.
|
|
|
|
*
|
|
|
|
* This file is part of OctaSTD. See COPYING.md for futher information.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef OCTA_ATOMIC_H
|
|
|
|
#define OCTA_ATOMIC_H
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
|
|
|
|
#include "octa/types.h"
|
|
|
|
#include "octa/type_traits.h"
|
|
|
|
|
|
|
|
namespace octa {
|
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
enum class MemoryOrder {
|
|
|
|
relaxed = 0,
|
|
|
|
consume,
|
|
|
|
acquire,
|
|
|
|
release,
|
|
|
|
acq_rel,
|
|
|
|
seq_cst
|
|
|
|
};
|
|
|
|
|
|
|
|
namespace detail {
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-03 23:20:19 +00:00
|
|
|
struct AtomicBase {
|
|
|
|
AtomicBase() {}
|
2015-06-04 21:57:06 +00:00
|
|
|
explicit AtomicBase(T v): p_value(v) {}
|
|
|
|
T p_value;
|
2015-05-01 19:34:32 +00:00
|
|
|
};
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T> T atomic_create();
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename U>
|
|
|
|
EnableIf<sizeof(T()->value = atomic_create<U>()), char>
|
2015-06-03 23:20:19 +00:00
|
|
|
test_atomic_assignable(int);
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename U>
|
2015-06-03 23:20:19 +00:00
|
|
|
int test_atomic_assignable(...);
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename U>
|
2015-06-03 23:20:19 +00:00
|
|
|
struct CanAtomicAssign {
|
2015-05-01 19:34:32 +00:00
|
|
|
static constexpr bool value
|
2015-06-04 21:57:06 +00:00
|
|
|
= (sizeof(test_atomic_assignable<T, U>(1)) == sizeof(char));
|
2015-05-01 19:34:32 +00:00
|
|
|
};
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-05-01 19:34:32 +00:00
|
|
|
static inline EnableIf<
|
2015-06-04 21:57:06 +00:00
|
|
|
CanAtomicAssign<volatile AtomicBase<T> *, T>::value
|
|
|
|
> atomic_init(volatile AtomicBase<T> *a, T v) {
|
2015-06-03 23:20:19 +00:00
|
|
|
a->p_value = v;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-05-01 19:34:32 +00:00
|
|
|
static inline EnableIf<
|
2015-06-04 21:57:06 +00:00
|
|
|
!CanAtomicAssign<volatile AtomicBase<T> *, T>::value &&
|
|
|
|
CanAtomicAssign< AtomicBase<T> *, T>::value
|
|
|
|
> atomic_init(volatile AtomicBase<T> *a, T v) {
|
2015-06-03 23:20:19 +00:00
|
|
|
volatile char *to = (volatile char *)(&a->p_value);
|
2015-06-04 21:57:06 +00:00
|
|
|
volatile char *end = to + sizeof(T);
|
2015-06-03 23:20:19 +00:00
|
|
|
char *from = (char *)(&v);
|
|
|
|
while (to != end) *to++ =*from++;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline void atomic_init(AtomicBase<T> *a, T v) {
|
2015-06-03 23:20:19 +00:00
|
|
|
a->p_value = v;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
2015-06-03 23:20:19 +00:00
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
|
|
|
/* GCC, Clang support
|
|
|
|
*
|
|
|
|
* libc++ used for reference
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef __GNUC__
|
|
|
|
|
|
|
|
#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
|
|
|
|
#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
|
|
|
|
#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
|
|
|
|
#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
|
2015-06-04 21:57:06 +00:00
|
|
|
#define ATOMIC_WCHART_LOCK_FREE __GCC_ATOMIC_WCHART_LOCK_FREE
|
2015-05-01 19:34:32 +00:00
|
|
|
#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
|
|
|
|
#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
|
|
|
|
#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
|
|
|
|
#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
|
|
|
|
#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
|
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
namespace detail {
|
|
|
|
static inline constexpr int to_gcc_order(MemoryOrder ord) {
|
|
|
|
return ((ord == MemoryOrder::relaxed) ? __ATOMIC_RELAXED :
|
|
|
|
((ord == MemoryOrder::acquire) ? __ATOMIC_ACQUIRE :
|
|
|
|
((ord == MemoryOrder::release) ? __ATOMIC_RELEASE :
|
|
|
|
((ord == MemoryOrder::seq_cst) ? __ATOMIC_SEQ_CST :
|
|
|
|
((ord == MemoryOrder::acq_rel) ? __ATOMIC_ACQ_REL :
|
2015-05-01 19:34:32 +00:00
|
|
|
__ATOMIC_CONSUME)))));
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
static inline constexpr int to_gcc_failure_order(MemoryOrder ord) {
|
|
|
|
return ((ord == MemoryOrder::relaxed) ? __ATOMIC_RELAXED :
|
|
|
|
((ord == MemoryOrder::acquire) ? __ATOMIC_ACQUIRE :
|
|
|
|
((ord == MemoryOrder::release) ? __ATOMIC_RELAXED :
|
|
|
|
((ord == MemoryOrder::seq_cst) ? __ATOMIC_SEQ_CST :
|
|
|
|
((ord == MemoryOrder::acq_rel) ? __ATOMIC_ACQUIRE :
|
2015-05-01 19:34:32 +00:00
|
|
|
__ATOMIC_CONSUME)))));
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
static inline void atomic_thread_fence(MemoryOrder ord) {
|
|
|
|
__atomic_thread_fence(to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
static inline void atomic_signal_fence(MemoryOrder ord) {
|
|
|
|
__atomic_signal_fence(to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
static inline bool atomic_is_lock_free(octa::Size size) {
|
2015-05-01 19:34:32 +00:00
|
|
|
/* return __atomic_is_lock_free(size, 0); cannot be used on some platforms */
|
2015-06-03 23:20:19 +00:00
|
|
|
return size <= sizeof(void *);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline void atomic_store(volatile AtomicBase<T> *a,
|
|
|
|
T v, MemoryOrder ord) {
|
2015-06-03 23:20:19 +00:00
|
|
|
__atomic_store(&a->p_value, &v, to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline void atomic_store(AtomicBase<T> *a,
|
|
|
|
T v, MemoryOrder ord) {
|
2015-06-03 23:20:19 +00:00
|
|
|
__atomic_store(&a->p_value, &v, to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_load(volatile AtomicBase<T> *a,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder ord) {
|
2015-06-04 21:57:06 +00:00
|
|
|
T r;
|
2015-06-03 23:20:19 +00:00
|
|
|
__atomic_load(&a->p_value, &r, to_gcc_order(ord));
|
|
|
|
return r;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_load(AtomicBase<T> *a,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder ord) {
|
2015-06-04 21:57:06 +00:00
|
|
|
T r;
|
2015-06-03 23:20:19 +00:00
|
|
|
__atomic_load(&a->p_value, &r, to_gcc_order(ord));
|
|
|
|
return r;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_exchange(volatile AtomicBase<T> *a,
|
|
|
|
T v, MemoryOrder ord) {
|
|
|
|
T r;
|
2015-06-03 23:20:19 +00:00
|
|
|
__atomic_exchange(&a->p_value, &v, &r, to_gcc_order(ord));
|
|
|
|
return r;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_exchange(AtomicBase<T> *a,
|
|
|
|
T v, MemoryOrder ord) {
|
|
|
|
T r;
|
2015-06-03 23:20:19 +00:00
|
|
|
__atomic_exchange(&a->p_value, &v, &r, to_gcc_order(ord));
|
|
|
|
return r;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-03 23:20:19 +00:00
|
|
|
static inline bool atomic_compare_exchange_strong(
|
2015-06-04 21:57:06 +00:00
|
|
|
volatile AtomicBase<T> *a, T *expected, T v,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder success, MemoryOrder failure
|
2015-05-01 19:34:32 +00:00
|
|
|
) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_compare_exchange(&a->p_value, expected, &v, false,
|
|
|
|
to_gcc_order(success), to_gcc_failure_order(failure));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-03 23:20:19 +00:00
|
|
|
static inline bool atomic_compare_exchange_strong(
|
2015-06-04 21:57:06 +00:00
|
|
|
AtomicBase<T> *a, T *expected, T v,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder success, MemoryOrder failure
|
2015-05-01 19:34:32 +00:00
|
|
|
) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_compare_exchange(&a->p_value, expected, &v, false,
|
|
|
|
to_gcc_order(success), to_gcc_failure_order(failure));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-03 23:20:19 +00:00
|
|
|
static inline bool atomic_compare_exchange_weak(
|
2015-06-04 21:57:06 +00:00
|
|
|
volatile AtomicBase<T> *a, T *expected, T v,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder success, MemoryOrder failure
|
2015-05-01 19:34:32 +00:00
|
|
|
) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_compare_exchange(&a->p_value, expected, &v, true,
|
|
|
|
to_gcc_order(success), to_gcc_failure_order(failure));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-03 23:20:19 +00:00
|
|
|
static inline bool atomic_compare_exchange_weak(
|
2015-06-04 21:57:06 +00:00
|
|
|
AtomicBase<T> *a, T *expected, T v,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder success, MemoryOrder failure
|
2015-05-01 19:34:32 +00:00
|
|
|
) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_compare_exchange(&a->p_value, expected, &v, true,
|
|
|
|
to_gcc_order(success), to_gcc_failure_order(failure));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-08 20:20:12 +00:00
|
|
|
struct SkipAmt { static constexpr octa::Size value = 1; };
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-08 20:20:12 +00:00
|
|
|
struct SkipAmt<T *> { static constexpr octa::Size value = sizeof(T); };
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T> struct SkipAmt<T[]> {};
|
2015-06-08 20:20:12 +00:00
|
|
|
template<typename T, octa::Size N> struct SkipAmt<T[N]> {};
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename U>
|
|
|
|
static inline T atomic_fetch_add(volatile AtomicBase<T> *a,
|
|
|
|
U d, MemoryOrder ord) {
|
|
|
|
return __atomic_fetch_add(&a->p_value, d * SkipAmt<T>::value,
|
2015-06-03 23:20:19 +00:00
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename U>
|
|
|
|
static inline T atomic_fetch_add(AtomicBase<T> *a,
|
|
|
|
U d, MemoryOrder ord) {
|
|
|
|
return __atomic_fetch_add(&a->p_value, d * SkipAmt<T>::value,
|
2015-06-03 23:20:19 +00:00
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename U>
|
|
|
|
static inline T atomic_fetch_sub(volatile AtomicBase<T> *a,
|
|
|
|
U d, MemoryOrder ord) {
|
|
|
|
return __atomic_fetch_sub(&a->p_value, d * SkipAmt<T>::value,
|
2015-06-03 23:20:19 +00:00
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename U>
|
|
|
|
static inline T atomic_fetch_sub(AtomicBase<T> *a,
|
|
|
|
U d, MemoryOrder ord) {
|
|
|
|
return __atomic_fetch_sub(&a->p_value, d * SkipAmt<T>::value,
|
2015-06-03 23:20:19 +00:00
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_fetch_and(volatile AtomicBase<T> *a,
|
|
|
|
T pattern, MemoryOrder ord) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_fetch_and(&a->p_value, pattern,
|
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_fetch_and(AtomicBase<T> *a,
|
|
|
|
T pattern, MemoryOrder ord) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_fetch_and(&a->p_value, pattern,
|
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_fetch_or(volatile AtomicBase<T> *a,
|
|
|
|
T pattern, MemoryOrder ord) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_fetch_or(&a->p_value, pattern,
|
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_fetch_or(AtomicBase<T> *a,
|
|
|
|
T pattern, MemoryOrder ord) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_fetch_or(&a->p_value, pattern,
|
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_fetch_xor(volatile AtomicBase<T> *a,
|
|
|
|
T pattern, MemoryOrder ord) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_fetch_xor(&a->p_value, pattern,
|
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
static inline T atomic_fetch_xor(AtomicBase<T> *a,
|
|
|
|
T pattern, MemoryOrder ord) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return __atomic_fetch_xor(&a->p_value, pattern,
|
|
|
|
to_gcc_order(ord));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
2015-06-03 23:20:19 +00:00
|
|
|
} /* namespace detail */
|
2015-05-01 19:34:32 +00:00
|
|
|
#else
|
|
|
|
# error Unsupported compiler
|
|
|
|
#endif
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template <typename T> inline T kill_dependency(T v) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return v;
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
namespace detail {
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, bool = octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value>
|
2015-06-03 23:20:19 +00:00
|
|
|
struct Atomic {
|
2015-06-04 21:57:06 +00:00
|
|
|
mutable AtomicBase<T> p_a;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
Atomic() = default;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
constexpr Atomic(T v): p_a(v) {}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
Atomic(const Atomic &) = delete;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
Atomic &operator=(const Atomic &) = delete;
|
|
|
|
Atomic &operator=(const Atomic &) volatile = delete;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-05-20 21:05:41 +00:00
|
|
|
bool is_lock_free() const volatile {
|
2015-06-04 21:57:06 +00:00
|
|
|
return atomic_is_lock_free(sizeof(T));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-05-20 21:05:41 +00:00
|
|
|
bool is_lock_free() const {
|
2015-06-04 21:57:06 +00:00
|
|
|
return atomic_is_lock_free(sizeof(T));
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
void store(T v, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
atomic_store(&p_a, v, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
void store(T v, MemoryOrder ord = MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
atomic_store(&p_a, v, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T load(MemoryOrder ord = MemoryOrder::seq_cst) const volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_load(&p_a, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T load(MemoryOrder ord = MemoryOrder::seq_cst) const {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_load(&p_a, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
operator T() const volatile { return load(); }
|
|
|
|
operator T() const { return load(); }
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T exchange(T v, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_exchange(&p_a, v, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T exchange(T v, MemoryOrder ord = MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_exchange(&p_a, v, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
bool compare_exchange_weak(T &e, T v, MemoryOrder s,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder f) volatile {
|
|
|
|
return atomic_compare_exchange_weak(&p_a, &e, v, s, f);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
bool compare_exchange_weak(T &e, T v, MemoryOrder s,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder f) {
|
|
|
|
return atomic_compare_exchange_weak(&p_a, &e, v, s, f);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
bool compare_exchange_strong(T &e, T v, MemoryOrder s,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder f) volatile {
|
|
|
|
return atomic_compare_exchange_strong(&p_a, &e, v, s, f);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
bool compare_exchange_strong(T &e, T v, MemoryOrder s,
|
2015-06-03 23:20:19 +00:00
|
|
|
MemoryOrder f) {
|
|
|
|
return atomic_compare_exchange_strong(&p_a, &e, v, s, f);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
bool compare_exchange_weak(T &e, T v, MemoryOrder ord
|
2015-05-19 23:24:20 +00:00
|
|
|
= MemoryOrder::seq_cst)
|
2015-05-20 21:05:41 +00:00
|
|
|
volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_compare_exchange_weak(&p_a, &e, v, ord, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
bool compare_exchange_weak(T &e, T v, MemoryOrder ord
|
2015-05-20 21:05:41 +00:00
|
|
|
= MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_compare_exchange_weak(&p_a, &e, v, ord, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
bool compare_exchange_strong(T &e, T v, MemoryOrder ord
|
2015-05-19 23:24:20 +00:00
|
|
|
= MemoryOrder::seq_cst)
|
2015-05-20 21:05:41 +00:00
|
|
|
volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_compare_exchange_strong(&p_a, &e, v, ord, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
bool compare_exchange_strong(T &e, T v, MemoryOrder ord
|
2015-05-20 21:05:41 +00:00
|
|
|
= MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_compare_exchange_strong(&p_a, &e, v, ord, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
struct Atomic<T, true>: Atomic<T, false> {
|
2015-06-07 23:55:08 +00:00
|
|
|
using Base = Atomic<T, false>;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-03 23:20:19 +00:00
|
|
|
Atomic() = default;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
constexpr Atomic(T v): Base(v) {}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_add(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_add(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_add(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_add(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_sub(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_sub(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_sub(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_sub(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_and(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_and(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_and(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_and(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_or(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_or(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_or(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_or(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_xor(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_xor(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T fetch_xor(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
|
2015-06-03 23:20:19 +00:00
|
|
|
return atomic_fetch_xor(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T operator++(int) volatile { return fetch_add(T(1)); }
|
|
|
|
T operator++(int) { return fetch_add(T(1)); }
|
|
|
|
T operator--(int) volatile { return fetch_sub(T(1)); }
|
|
|
|
T operator--(int) { return fetch_sub(T(1)); }
|
|
|
|
T operator++( ) volatile { return fetch_add(T(1)) + T(1); }
|
|
|
|
T operator++( ) { return fetch_add(T(1)) + T(1); }
|
|
|
|
T operator--( ) volatile { return fetch_sub(T(1)) - T(1); }
|
|
|
|
T operator--( ) { return fetch_sub(T(1)) - T(1); }
|
|
|
|
|
|
|
|
T operator+=(T op) volatile { return fetch_add(op) + op; }
|
|
|
|
T operator+=(T op) { return fetch_add(op) + op; }
|
|
|
|
T operator-=(T op) volatile { return fetch_sub(op) - op; }
|
|
|
|
T operator-=(T op) { return fetch_sub(op) - op; }
|
|
|
|
T operator&=(T op) volatile { return fetch_and(op) & op; }
|
|
|
|
T operator&=(T op) { return fetch_and(op) & op; }
|
|
|
|
T operator|=(T op) volatile { return fetch_or (op) | op; }
|
|
|
|
T operator|=(T op) { return fetch_or (op) | op; }
|
|
|
|
T operator^=(T op) volatile { return fetch_xor(op) ^ op; }
|
|
|
|
T operator^=(T op) { return fetch_xor(op) ^ op; }
|
2015-05-01 19:34:32 +00:00
|
|
|
};
|
2015-06-03 23:20:19 +00:00
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template<typename T>
|
|
|
|
struct Atomic: octa::detail::Atomic<T> {
|
|
|
|
using Base = octa::detail::Atomic<T>;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
Atomic() = default;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
constexpr Atomic(T v): Base(v) {}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T operator=(T v) volatile {
|
|
|
|
Base::store(v); return v;
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T operator=(T v) {
|
|
|
|
Base::store(v); return v;
|
|
|
|
}
|
|
|
|
};
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template<typename T>
|
|
|
|
struct Atomic<T *>: octa::detail::Atomic<T *> {
|
|
|
|
using Base = octa::detail::Atomic<T *>;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
Atomic() = default;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
constexpr Atomic(T *v): Base(v) {}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T *operator=(T *v) volatile {
|
|
|
|
Base::store(v); return v;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T *operator=(T *v) {
|
|
|
|
Base::store(v); return v;
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T *fetch_add(octa::Ptrdiff op, MemoryOrder ord = MemoryOrder::seq_cst)
|
|
|
|
volatile {
|
|
|
|
return octa::detail::atomic_fetch_add(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T *fetch_add(octa::Ptrdiff op, MemoryOrder ord = MemoryOrder::seq_cst) {
|
|
|
|
return octa::detail::atomic_fetch_add(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T *fetch_sub(octa::Ptrdiff op, MemoryOrder ord = MemoryOrder::seq_cst)
|
|
|
|
volatile {
|
|
|
|
return octa::detail::atomic_fetch_sub(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T *fetch_sub(octa::Ptrdiff op, MemoryOrder ord = MemoryOrder::seq_cst) {
|
|
|
|
return octa::detail::atomic_fetch_sub(&this->p_a, op, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T *operator++(int) volatile { return fetch_add(1); }
|
|
|
|
T *operator++(int) { return fetch_add(1); }
|
|
|
|
T *operator--(int) volatile { return fetch_sub(1); }
|
|
|
|
T *operator--(int) { return fetch_sub(1); }
|
|
|
|
T *operator++( ) volatile { return fetch_add(1) + 1; }
|
|
|
|
T *operator++( ) { return fetch_add(1) + 1; }
|
|
|
|
T *operator--( ) volatile { return fetch_sub(1) - 1; }
|
|
|
|
T *operator--( ) { return fetch_sub(1) - 1; }
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
T *operator+=(octa::Ptrdiff op) volatile { return fetch_add(op) + op; }
|
|
|
|
T *operator+=(octa::Ptrdiff op) { return fetch_add(op) + op; }
|
|
|
|
T *operator-=(octa::Ptrdiff op) volatile { return fetch_sub(op) - op; }
|
|
|
|
T *operator-=(octa::Ptrdiff op) { return fetch_sub(op) - op; }
|
|
|
|
};
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template<typename T>
|
|
|
|
inline bool atomic_is_lock_free(const volatile Atomic<T> *a) {
|
|
|
|
return a->is_lock_free();
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template<typename T>
|
|
|
|
inline bool atomic_is_lock_free(const Atomic<T> *a) {
|
|
|
|
return a->is_lock_free();
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template<typename T>
|
|
|
|
inline void atomic_init(volatile Atomic<T> *a, T v) {
|
|
|
|
octa::detail::atomic_init(&a->p_a, v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template<typename T>
|
|
|
|
inline void atomic_init(Atomic<T> *a, T v) {
|
|
|
|
octa::detail::atomic_init(&a->p_a, v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline void atomic_store(volatile Atomic<T> *a, T v) {
|
|
|
|
a->store(v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline void atomic_store(Atomic<T> *a, T v) {
|
|
|
|
a->store(v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline void atomic_store_explicit(volatile Atomic<T> *a, T v,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
a->store(v, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline void atomic_store_explicit(Atomic<T> *a, T v,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
a->store(v, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T atomic_load(const volatile Atomic<T> *a) {
|
|
|
|
return a->load();
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T atomic_load(const Atomic<T> *a) {
|
|
|
|
return a->load();
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T atomic_load_explicit(const volatile Atomic<T> *a,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->load(ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T atomic_load_explicit(const Atomic<T> *a, MemoryOrder ord) {
|
|
|
|
return a->load(ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T atomic_exchange(volatile Atomic<T> *a, T v) {
|
|
|
|
return a->exchange(v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T atomic_exchange(Atomic<T> *a, T v) {
|
|
|
|
return a->exchange(v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T atomic_exchange_explicit(volatile Atomic<T> *a, T v,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->exchange(v, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T atomic_exchange_explicit(Atomic<T> *a, T v,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->exchange(v, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline bool atomic_compare_exchange_weak(volatile Atomic<T> *a,
|
|
|
|
T *e, T v) {
|
|
|
|
return a->compare_exchange_weak(*e, v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline bool atomic_compare_exchange_weak(Atomic<T> *a, T *e, T v) {
|
|
|
|
return a->compare_exchange_weak(*e, v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline bool atomic_compare_exchange_strong(volatile Atomic<T> *a,
|
|
|
|
T *e, T v) {
|
|
|
|
return a->compare_exchange_strong(*e, v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline bool atomic_compare_exchange_strong(Atomic<T> *a, T *e, T v) {
|
|
|
|
return a->compare_exchange_strong(*e, v);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline bool atomic_compare_exchange_weak_explicit(volatile Atomic<T> *a,
|
|
|
|
T *e, T v,
|
|
|
|
MemoryOrder s,
|
|
|
|
MemoryOrder f) {
|
|
|
|
return a->compare_exchange_weak(*e, v, s, f);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline bool atomic_compare_exchange_weak_explicit(Atomic<T> *a, T *e,
|
|
|
|
T v,
|
|
|
|
MemoryOrder s,
|
|
|
|
MemoryOrder f) {
|
|
|
|
return a->compare_exchange_weak(*e, v, s, f);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline bool atomic_compare_exchange_strong_explicit(volatile Atomic<T> *a,
|
|
|
|
T *e, T v,
|
|
|
|
MemoryOrder s,
|
|
|
|
MemoryOrder f) {
|
|
|
|
return a->compare_exchange_strong(*e, v, s, f);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline bool atomic_compare_exchange_strong_explicit(Atomic<T> *a, T *e,
|
|
|
|
T v,
|
|
|
|
MemoryOrder s,
|
|
|
|
MemoryOrder f) {
|
|
|
|
return a->compare_exchange_strong(*e, v, s, f);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_add(volatile Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_add(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_add(Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_add(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T *atomic_fetch_add(volatile Atomic<T *> *a, octa::Ptrdiff op) {
|
|
|
|
return a->fetch_add(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T *atomic_fetch_add(Atomic<T *> *a, octa::Ptrdiff op) {
|
|
|
|
return a->fetch_add(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_add_explicit(volatile Atomic<T> *a, T op,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->fetch_add(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_add_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
|
|
|
|
return a->fetch_add(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T *atomic_fetch_add_explicit(volatile Atomic<T *> *a,
|
|
|
|
octa::Ptrdiff op, MemoryOrder ord) {
|
|
|
|
return a->fetch_add(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T *atomic_fetch_add_explicit(Atomic<T *> *a, octa::Ptrdiff op,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->fetch_add(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_sub(volatile Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_sub(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_sub(Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_sub(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T *atomic_fetch_sub(volatile Atomic<T *> *a, octa::Ptrdiff op) {
|
|
|
|
return a->fetch_sub(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T *atomic_fetch_sub(Atomic<T *> *a, octa::Ptrdiff op) {
|
|
|
|
return a->fetch_sub(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_sub_explicit(volatile Atomic<T> *a, T op,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->fetch_sub(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_sub_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
|
|
|
|
return a->fetch_sub(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T *atomic_fetch_sub_explicit(volatile Atomic<T *> *a,
|
|
|
|
octa::Ptrdiff op, MemoryOrder ord) {
|
|
|
|
return a->fetch_sub(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline T *atomic_fetch_sub_explicit(Atomic<T *> *a, octa::Ptrdiff op,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->fetch_sub(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_and(volatile Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_and(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_and(Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_and(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_and_explicit(volatile Atomic<T> *a, T op,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->fetch_and(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_and_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
|
|
|
|
return a->fetch_and(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_or(volatile Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_or(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_or(Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_or(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_or_explicit(volatile Atomic<T> *a, T op,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->fetch_or(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_or_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
|
|
|
|
return a->fetch_or(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_xor(volatile Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_xor(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_xor(Atomic<T> *a, T op) {
|
|
|
|
return a->fetch_xor(op);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_xor_explicit(volatile Atomic<T> *a, T op,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->fetch_xor(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
template <typename T>
|
|
|
|
inline octa::EnableIf<octa::IsIntegral<T>::value &&
|
|
|
|
!octa::IsSame<T, bool>::value, T>
|
|
|
|
atomic_fetch_xor_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
|
|
|
|
return a->fetch_xor(op, ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
struct AtomicFlag {
|
|
|
|
octa::detail::AtomicBase<bool> p_a;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
AtomicFlag() = default;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
AtomicFlag(bool b): p_a(b) {}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
AtomicFlag(const AtomicFlag &) = delete;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
AtomicFlag &operator=(const AtomicFlag &) = delete;
|
|
|
|
AtomicFlag &operator=(const AtomicFlag &) volatile = delete;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
|
|
|
return octa::detail::atomic_exchange(&p_a, true, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) {
|
|
|
|
return octa::detail::atomic_exchange(&p_a, true, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
void clear(MemoryOrder ord = MemoryOrder::seq_cst) volatile {
|
|
|
|
octa::detail::atomic_store(&p_a, false, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
void clear(MemoryOrder ord = MemoryOrder::seq_cst) {
|
|
|
|
octa::detail::atomic_store(&p_a, false, ord);
|
2015-05-01 19:34:32 +00:00
|
|
|
}
|
2015-06-08 20:20:12 +00:00
|
|
|
};
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
inline bool atomic_flag_test_and_set(volatile AtomicFlag *a) {
|
|
|
|
return a->test_and_set();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool atomic_flag_test_and_set(AtomicFlag *a) {
|
|
|
|
return a->test_and_set();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool atomic_flag_test_and_set_explicit(volatile AtomicFlag *a,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->test_and_set(ord);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool atomic_flag_test_and_set_explicit(AtomicFlag *a,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
return a->test_and_set(ord);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void atomic_flag_clear(volatile AtomicFlag *a) {
|
|
|
|
a->clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void atomic_flag_clear(AtomicFlag *a) {
|
|
|
|
a->clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void atomic_flag_clear_explicit(volatile AtomicFlag *a,
|
|
|
|
MemoryOrder ord) {
|
|
|
|
a->clear(ord);
|
|
|
|
}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
inline void atomic_flag_clear_explicit(AtomicFlag *a, MemoryOrder ord) {
|
|
|
|
a->clear(ord);
|
|
|
|
}
|
2015-06-07 23:55:08 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
inline void atomic_thread_fence(MemoryOrder ord) {
|
|
|
|
octa::detail::atomic_thread_fence(ord);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void atomic_signal_fence(MemoryOrder ord) {
|
|
|
|
octa::detail::atomic_signal_fence(ord);
|
|
|
|
}
|
2015-06-07 23:55:08 +00:00
|
|
|
|
2015-06-08 20:20:12 +00:00
|
|
|
using AtomicBool = Atomic<bool>;
|
|
|
|
using AtomicChar = Atomic<char>;
|
|
|
|
using AtomicShort = Atomic<short>;
|
|
|
|
using AtomicInt = Atomic<int>;
|
|
|
|
using AtomicLong = Atomic<long>;
|
|
|
|
using AtomicSchar = Atomic<octa::schar>;
|
|
|
|
using AtomicUchar = Atomic<octa::uchar>;
|
|
|
|
using AtomicUshort = Atomic<octa::ushort>;
|
|
|
|
using AtomicUint = Atomic<octa::uint>;
|
|
|
|
using AtomicUlong = Atomic<octa::ulong>;
|
|
|
|
using AtomicLlong = Atomic<octa::llong>;
|
|
|
|
using AtomicUllong = Atomic<octa::ullong>;
|
|
|
|
|
|
|
|
using AtomicChar16 = Atomic<octa::Char16>;
|
|
|
|
using AtomicChar32 = Atomic<octa::Char32>;
|
|
|
|
using AtomicWchar = Atomic<octa::Wchar>;
|
|
|
|
|
|
|
|
using AtomicPtrdiff = Atomic<octa::Ptrdiff>;
|
|
|
|
using AtomicSize = Atomic<octa::Size>;
|
|
|
|
|
|
|
|
using AtomicIntmax = Atomic<octa::Intmax>;
|
|
|
|
using AtomicUintmax = Atomic<octa::Uintmax>;
|
|
|
|
|
|
|
|
using AtomicIntptr = Atomic<octa::Intptr>;
|
|
|
|
using AtomicUintptr = Atomic<octa::Uintptr>;
|
|
|
|
|
|
|
|
using AtomicInt8 = Atomic<octa::Int8>;
|
|
|
|
using AtomicInt16 = Atomic<octa::Int16>;
|
|
|
|
using AtomicInt32 = Atomic<octa::Int32>;
|
|
|
|
using AtomicInt64 = Atomic<octa::Int64>;
|
|
|
|
|
|
|
|
using AtomicUint8 = Atomic<octa::Uint8>;
|
|
|
|
using AtomicUint16 = Atomic<octa::Uint16>;
|
|
|
|
using AtomicUint32 = Atomic<octa::Uint32>;
|
|
|
|
using AtomicUint64 = Atomic<octa::Uint64>;
|
|
|
|
|
|
|
|
using AtomicIntLeast8 = Atomic<octa::IntLeast8>;
|
|
|
|
using AtomicIntLeast16 = Atomic<octa::IntLeast16>;
|
|
|
|
using AtomicIntLeast32 = Atomic<octa::IntLeast32>;
|
|
|
|
using AtomicIntLeast64 = Atomic<octa::IntLeast64>;
|
|
|
|
|
|
|
|
using AtomicUintLeast8 = Atomic<octa::UintLeast8>;
|
|
|
|
using AtomicUintLeast16 = Atomic<octa::UintLeast16>;
|
|
|
|
using AtomicUintLeast32 = Atomic<octa::UintLeast32>;
|
|
|
|
using AtomicUintLeast64 = Atomic<octa::UintLeast64>;
|
|
|
|
|
|
|
|
using AtomicIntFast8 = Atomic<octa::IntFast8>;
|
|
|
|
using AtomicIntFast16 = Atomic<octa::IntFast16>;
|
|
|
|
using AtomicIntFast32 = Atomic<octa::IntFast32>;
|
|
|
|
using AtomicIntFast64 = Atomic<octa::IntFast64>;
|
|
|
|
|
|
|
|
using AtomicUintFast8 = Atomic<octa::UintFast8>;
|
|
|
|
using AtomicUintFast16 = Atomic<octa::UintFast16>;
|
|
|
|
using AtomicUintFast32 = Atomic<octa::UintFast32>;
|
|
|
|
using AtomicUintFast64 = Atomic<octa::UintFast64>;
|
2015-05-01 19:34:32 +00:00
|
|
|
|
|
|
|
#define ATOMIC_FLAG_INIT {false}
|
2015-06-03 23:20:19 +00:00
|
|
|
#define ATOMIC_VAR_INIT(v) {v}
|
2015-05-01 19:34:32 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|