| //===----------------------------------------------------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is dual licensed under the MIT and the University of Illinois Open |
| // Source Licenses. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // <atomic> |
| |
| // typedef struct atomic_address |
| // { |
| // bool is_lock_free() const volatile; |
| // bool is_lock_free() const; |
| // void store(void*, memory_order = memory_order_seq_cst) volatile; |
| // void store(void*, memory_order = memory_order_seq_cst); |
| // void* load(memory_order = memory_order_seq_cst) const volatile; |
| // void* load(memory_order = memory_order_seq_cst) const; |
| // operator void*() const volatile; |
| // operator void*() const; |
| // void* exchange(void*, memory_order = memory_order_seq_cst) volatile; |
| // void* exchange(void*, memory_order = memory_order_seq_cst); |
| // bool compare_exchange_weak(void*&, void*, memory_order, |
| // memory_order) volatile; |
| // bool compare_exchange_weak(void*&, void*, memory_order, memory_order); |
| // bool compare_exchange_strong(void*&, void*, memory_order, |
| // memory_order) volatile; |
| // bool compare_exchange_strong(void*&, void*, memory_order, memory_order); |
| // bool compare_exchange_weak(void*&, void*, |
| // memory_order = memory_order_seq_cst) volatile; |
| // bool compare_exchange_weak(void*&, void*, |
| // memory_order = memory_order_seq_cst); |
| // bool compare_exchange_strong(void*&, void*, |
| // memory_order = memory_order_seq_cst) volatile; |
| // bool compare_exchange_strong(void*&, void*, |
| // memory_order = memory_order_seq_cst); |
| // bool compare_exchange_weak(const void*&, const void*, |
| // memory_order, memory_order) volatile; |
| // bool compare_exchange_weak(const void*&, const void*, memory_order, |
| // memory_order); |
| // bool compare_exchange_strong(const void*&, const void*, memory_order, |
| // memory_order) volatile; |
| // bool compare_exchange_strong(const void*&, const void*, memory_order, |
| // memory_order); |
| // bool compare_exchange_weak(const void*&, const void*, |
| // memory_order = memory_order_seq_cst) volatile; |
| // bool compare_exchange_weak(const void*&, const void*, |
| // memory_order = memory_order_seq_cst); |
| // bool compare_exchange_strong(const void*&, const void*, |
| // memory_order = memory_order_seq_cst) volatile; |
| // bool compare_exchange_strong(const void*&, const void*, |
| // memory_order = memory_order_seq_cst); |
| // void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile; |
| // void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst); |
| // void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile; |
| // void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst); |
| // atomic_address() = default; |
| // constexpr atomic_address(void*); |
| // atomic_address(const atomic_address&) = delete; |
| // atomic_address& operator=(const atomic_address&) = delete; |
| // atomic_address& operator=(const atomic_address&) volatile = delete; |
| // void* operator=(const void*) volatile; |
| // void* operator=(const void*); |
| // void* operator+=(ptrdiff_t) volatile; |
| // void* operator+=(ptrdiff_t); |
| // void* operator-=(ptrdiff_t) volatile; |
| // void* operator-=(ptrdiff_t); |
| // } atomic_address; |
| // |
| // bool atomic_is_lock_free(const volatile atomic_address*); |
| // bool atomic_is_lock_free(const atomic_address*); |
| // void atomic_init(volatile atomic_address*, void*); |
| // void atomic_init(atomic_address*, void*); |
| // void atomic_store(volatile atomic_address*, void*); |
| // void atomic_store(atomic_address*, void*); |
| // void atomic_store_explicit(volatile atomic_address*, void*, memory_order); |
| // void atomic_store_explicit(atomic_address*, void*, memory_order); |
| // void* atomic_load(const volatile atomic_address*); |
| // void* atomic_load(const atomic_address*); |
| // void* atomic_load_explicit(const volatile atomic_address*, memory_order); |
| // void* atomic_load_explicit(const atomic_address*, memory_order); |
| // void* atomic_exchange(volatile atomic_address*, void*); |
| // void* atomic_exchange(atomic_address*, void*); |
| // void* atomic_exchange_explicit(volatile atomic_address*, void*, memory_order); |
| // void* atomic_exchange_explicit(atomic_address*, void*, memory_order); |
| // bool atomic_compare_exchange_weak(volatile atomic_address*, void**, void*); |
| // bool atomic_compare_exchange_weak(atomic_address*, void**, void*); |
| // bool atomic_compare_exchange_strong(volatile atomic_address*, void**, void*); |
| // bool atomic_compare_exchange_strong(atomic_address*, void**, void*); |
| // bool atomic_compare_exchange_weak_explicit(volatile atomic_address*, void**, |
| // void*, memory_order, memory_order); |
| // bool atomic_compare_exchange_weak_explicit(atomic_address*, void**, void*, |
| // memory_order, memory_order); |
| // bool atomic_compare_exchange_strong_explicit(volatile atomic_address*, void**, |
| // void*, memory_order, memory_order); |
| // bool atomic_compare_exchange_strong_explicit(atomic_address*, void**, void*, |
| // memory_order, memory_order); |
| // void* atomic_fetch_add(volatile atomic_address*, ptrdiff_t); |
| // void* atomic_fetch_add(atomic_address*, ptrdiff_t); |
| // void* atomic_fetch_add_explicit(volatile atomic_address*, ptrdiff_t, |
| // memory_order); |
| // void* atomic_fetch_add_explicit(atomic_address*, ptrdiff_t, memory_order); |
| // void* atomic_fetch_sub(volatile atomic_address*, ptrdiff_t); |
| // void* atomic_fetch_sub(atomic_address*, ptrdiff_t); |
| // void* atomic_fetch_sub_explicit(volatile atomic_address*, ptrdiff_t, |
| // memory_order); |
| // void* atomic_fetch_sub_explicit(atomic_address*, ptrdiff_t, memory_order); |
| |
| #include <atomic> |
| #include <cassert> |
| |
| template <class A, class T> |
| void |
| do_test() |
| { |
| A obj(T(0)); |
| assert(obj == T(0)); |
| std::atomic_init(&obj, T(1)); |
| assert(obj == T(1)); |
| std::atomic_init(&obj, T(2)); |
| assert(obj == T(2)); |
| bool b0 = obj.is_lock_free(); |
| obj.store(T(0)); |
| assert(obj == T(0)); |
| obj.store(T(1), std::memory_order_release); |
| assert(obj == T(1)); |
| assert(obj.load() == T(1)); |
| assert(obj.load(std::memory_order_acquire) == T(1)); |
| assert(obj.exchange(T(2)) == T(1)); |
| assert(obj == T(2)); |
| assert(obj.exchange(T(3), std::memory_order_relaxed) == T(2)); |
| assert(obj == T(3)); |
| T x = obj; |
| assert(obj.compare_exchange_weak(x, T(2)) == true); |
| assert(obj == T(2)); |
| assert(x == T(3)); |
| assert(obj.compare_exchange_weak(x, T(1)) == false); |
| assert(obj == T(2)); |
| assert(x == T(2)); |
| assert(obj.compare_exchange_strong(x, T(1)) == true); |
| assert(obj == T(1)); |
| assert(x == T(2)); |
| assert(obj.compare_exchange_strong(x, T(0)) == false); |
| assert(obj == T(1)); |
| assert(x == T(1)); |
| assert((obj = T(0)) == T(0)); |
| assert(obj == T(0)); |
| obj = T(2); |
| assert((obj += std::ptrdiff_t(3)) == T(5)); |
| assert(obj == T(5)); |
| assert((obj -= std::ptrdiff_t(3)) == T(2)); |
| assert(obj == T(2)); |
| |
| std::atomic_init(&obj, T(1)); |
| assert(obj == T(1)); |
| bool b1 = std::atomic_is_lock_free(&obj); |
| std::atomic_store(&obj, T(0)); |
| assert(obj == T(0)); |
| std::atomic_store_explicit(&obj, T(1), std::memory_order_release); |
| assert(obj == T(1)); |
| assert(std::atomic_load(&obj) == T(1)); |
| assert(std::atomic_load_explicit(&obj, std::memory_order_acquire) == T(1)); |
| assert(std::atomic_exchange(&obj, T(2)) == T(1)); |
| assert(obj == T(2)); |
| assert(std::atomic_exchange_explicit(&obj, T(3), std::memory_order_relaxed) == T(2)); |
| assert(obj == T(3)); |
| x = obj; |
| assert(std::atomic_compare_exchange_weak(&obj, &x, T(2)) == true); |
| assert(obj == T(2)); |
| assert(x == T(3)); |
| assert(std::atomic_compare_exchange_weak(&obj, &x, T(1)) == false); |
| assert(obj == T(2)); |
| assert(x == T(2)); |
| assert(std::atomic_compare_exchange_strong(&obj, &x, T(1)) == true); |
| assert(obj == T(1)); |
| assert(x == T(2)); |
| assert(std::atomic_compare_exchange_strong(&obj, &x, T(0)) == false); |
| assert(obj == T(1)); |
| assert(x == T(1)); |
| assert(std::atomic_compare_exchange_weak_explicit(&obj, &x, T(2), |
| std::memory_order_relaxed, std::memory_order_relaxed) == true); |
| assert(obj == T(2)); |
| assert(x == T(1)); |
| assert(std::atomic_compare_exchange_weak_explicit(&obj, &x, T(3), |
| std::memory_order_relaxed, std::memory_order_relaxed) == false); |
| assert(obj == T(2)); |
| assert(x == T(2)); |
| assert(std::atomic_compare_exchange_strong_explicit(&obj, &x, T(3), |
| std::memory_order_relaxed, std::memory_order_relaxed) == true); |
| assert(obj == T(3)); |
| assert(x == T(2)); |
| assert(std::atomic_compare_exchange_strong_explicit(&obj, &x, T(0), |
| std::memory_order_relaxed, std::memory_order_relaxed) == false); |
| assert(obj == T(3)); |
| assert(x == T(3)); |
| assert((obj = T(1)) == T(1)); |
| assert(obj == T(1)); |
| obj = T(2); |
| assert(std::atomic_fetch_add(&obj, std::ptrdiff_t(3)) == T(2)); |
| assert(obj == T(5)); |
| assert(std::atomic_fetch_add_explicit(&obj, std::ptrdiff_t(3), std::memory_order_seq_cst) == T(5)); |
| assert(obj == T(8)); |
| assert(std::atomic_fetch_sub(&obj, std::ptrdiff_t(3)) == T(8)); |
| assert(obj == T(5)); |
| assert(std::atomic_fetch_sub_explicit(&obj, std::ptrdiff_t(3), std::memory_order_seq_cst) == T(5)); |
| assert(obj == T(2)); |
| } |
| |
| template <class A, class T> |
| void test() |
| { |
| do_test<A, T>(); |
| do_test<volatile A, T>(); |
| } |
| |
| int main() |
| { |
| test<std::atomic_address, void*>(); |
| } |