include/fbl/atomic.h

12 // fbl::atomic<T> provides typesafe C++ atomics on integral types,
23 // supported, as fbl::atomic<T> is not an aggregate.
32 // fbl::atomic<T>:
33 //   - atomic_init value initializes a default constructed atomic<T>
34 //   - atomic_OP are nonmember versions of atomic<T>::OP
41 // In addition, fbl::atomic does not provide the same compatibility
42 // guarantees with C11's <stdatomic.h> is std::atomic does
43 // (std::atomic is designed to allow interop with C by #define
44 // _Atomic(T) std::atomic<T> and so on). The types are not guaranteed
46 // make any of the fbl::atomic functions extern "C".
48 // However, fbl::atomic<T> _is_ guaranteed to have the same size and
64 struct atomic {
66                   "fbl::atomic only support integral, enum, and pointer types");
67     static_assert(!is_same<T, wchar_t>::value, "fbl::atomic does not support wide characters");
68     static_assert(!is_same<T, char16_t>::value, "fbl::atomic does not support wide characters");
69     static_assert(!is_same<T, char32_t>::value, "fbl::atomic does not support wide characters");
75     atomic() = default;
76     constexpr atomic(T value)
79     // Don't copy, move, or operator= atomic values. Use store instead
81     atomic(const atomic& value) = delete;
82     atomic(atomic&& value) = delete;
83     void operator=(atomic value) = delete;
84     void operator=(atomic value) volatile = delete;
85     atomic& operator=(const atomic& value) = delete;
86     atomic& operator=(const atomic& value) volatile = delete;
87     atomic& operator=(atomic&& value) = delete;
88     atomic& operator=(atomic&& value) volatile = delete;
145         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
149         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
154         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
158         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
163         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
167         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
172         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
176         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
181         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
185         static_assert(!fbl::is_same<T, bool>::value, "no arithmetic on atomic<bool>!");
191     friend void atomic_init(atomic<U>* atomic_ptr, U value);
193     friend void atomic_init(volatile atomic<U>* atomic_ptr, U value);
204 struct atomic<T*> {
207     atomic() = default;
208     constexpr atomic(T* value)
211     // Don't copy, move, or operator= atomic values. Use store instead
213     atomic(const atomic& value) = delete;
214     atomic(atomic&& value) = delete;
215     void operator=(atomic value) = delete;
216     void operator=(atomic value) volatile = delete;
217     atomic& operator=(const atomic& value) = delete;
218     atomic& operator=(const atomic& value) volatile = delete;
219     atomic& operator=(atomic&& value) = delete;
220     atomic& operator=(atomic&& value) volatile = delete;
296     friend void atomic_init(atomic<U>* atomic_ptr, U value);
298     friend void atomic_init(volatile atomic<U>* atomic_ptr, U value);
305 void atomic_store(atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
309 void atomic_store(volatile atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
314 T atomic_load(const atomic<T>* atomic_ptr, memory_order order = memory_order_seq_cst) {
318 T atomic_load(const volatile atomic<T>* atomic_ptr, memory_order order = memory_order_seq_cst) {
323 T atomic_exchange(atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
327 T atomic_exchange(volatile atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
332 bool atomic_compare_exchange_weak(atomic<T>* atomic_ptr, T* expected, T desired,
338 bool atomic_compare_exchange_weak(volatile atomic<T>* atomic_ptr, T* expected, T desired,
345 bool atomic_compare_exchange_strong(atomic<T>* atomic_ptr, T* expected, T desired,
352 bool atomic_compare_exchange_strong(volatile atomic<T>* atomic_ptr, T* expected, T desired,
360 atomic_fetch_add(atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
365 atomic_fetch_add(volatile atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
369 T* atomic_fetch_add(atomic<T*>* atomic_ptr, ptrdiff_t value, memory_order order = memory_order_seq_cst) {
373 T* atomic_fetch_add(volatile atomic<T*>* atomic_ptr, ptrdiff_t value, memory_order order = memory_order_seq_cst) {
379 atomic_fetch_sub(atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
384 atomic_fetch_sub(volatile atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
388 T* atomic_fetch_sub(atomic<T*>* atomic_ptr, ptrdiff_t value, memory_order order = memory_order_seq_cst) {
392 T* atomic_fetch_sub(volatile atomic<T*>* atomic_ptr, ptrdiff_t value, memory_order order = memory_order_seq_cst) {
397 T atomic_fetch_and(atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
401 T atomic_fetch_and(volatile atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
406 T atomic_fetch_or(atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
410 T atomic_fetch_or(volatile atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
415 T atomic_fetch_xor(atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
419 T atomic_fetch_xor(volatile atomic<T>* atomic_ptr, T value, memory_order order = memory_order_seq_cst) {
423 // Other atomic functions.
425 // atomic_init value initializes an uninitialized atomic<T>. Only
426 // default constructed atomic<T>s are uninitialized.
428 // This function is _not_ atomic: any other concurrent access (even if
429 // that access is atomic) is a data race.
431 // This function is _not_ a substitute for constructing the atomic<T>:
432 // it does not begin the lifetime of an atomic<T> object.
439 void atomic_init(atomic<T>* atomic_ptr, T value) {
443 void atomic_init(volatile atomic<T>* atomic_ptr, T value) {
448 // memory order, which synchronizes with other atomic operations and
458 // the corresponding atomic operation on a memory location, and may be
479 using atomic_char = atomic<char>;
480 using atomic_schar = atomic<signed char>;
481 using atomic_uchar = atomic<unsigned char>;
482 using atomic_short = atomic<short>;
483 using atomic_ushort = atomic<unsigned short>;
484 using atomic_int = atomic<int>;
485 using atomic_uint = atomic<unsigned int>;
486 using atomic_long = atomic<long>;
487 using atomic_ulong = atomic<unsigned long>;
488 using atomic_llong = atomic<long long>;
489 using atomic_ullong = atomic<unsigned long long>;
491 using atomic_intptr_t = atomic<intptr_t>;
492 using atomic_uintptr_t = atomic<uintptr_t>;
493 using atomic_size_t = atomic<size_t>;
494 using atomic_ptrdiff_t = atomic<ptrdiff_t>;
495 using atomic_intmax_t = atomic<intmax_t>;
496 using atomic_uintmax_t = atomic<uintmax_t>;
498 using atomic_int8_t = atomic<int8_t>;
499 using atomic_uint8_t = atomic<uint8_t>;
500 using atomic_int16_t = atomic<int16_t>;
501 using atomic_uint16_t = atomic<uint16_t>;
502 using atomic_int32_t = atomic<int32_t>;
503 using atomic_uint32_t = atomic<uint32_t>;
504 using atomic_int64_t = atomic<int64_t>;
505 using atomic_uint64_t = atomic<uint64_t>;
507 using atomic_int_least8_t = atomic<int_least8_t>;
508 using atomic_uint_least8_t = atomic<uint_least8_t>;
509 using atomic_int_least16_t = atomic<int_least16_t>;
510 using atomic_uint_least16_t = atomic<uint_least16_t>;
511 using atomic_int_least32_t = atomic<int_least32_t>;
512 using atomic_uint_least32_t = atomic<uint_least32_t>;
513 using atomic_int_least64_t = atomic<int_least64_t>;
514 using atomic_uint_least64_t = atomic<uint_least64_t>;
515 using atomic_int_fast8_t = atomic<int_fast8_t>;
516 using atomic_uint_fast8_t = atomic<uint_fast8_t>;
517 using atomic_int_fast16_t = atomic<int_fast16_t>;
518 using atomic_uint_fast16_t = atomic<uint_fast16_t>;
519 using atomic_int_fast32_t = atomic<int_fast32_t>;
520 using atomic_uint_fast32_t = atomic<uint_fast32_t>;
521 using atomic_int_fast64_t = atomic<int_fast64_t>;
522 using atomic_uint_fast64_t = atomic<uint_fast64_t>;
524 using atomic_bool = atomic<bool>;