1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <atomic> 11 12 // template <class T> 13 // struct atomic<T*> 14 // { 15 // bool is_lock_free() const volatile; 16 // bool is_lock_free() const; 17 // void store(T* desr, memory_order m = memory_order_seq_cst) volatile; 18 // void store(T* desr, memory_order m = memory_order_seq_cst); 19 // T* load(memory_order m = memory_order_seq_cst) const volatile; 20 // T* load(memory_order m = memory_order_seq_cst) const; 21 // operator T*() const volatile; 22 // operator T*() const; 23 // T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile; 24 // T* exchange(T* desr, memory_order m = memory_order_seq_cst); 25 // bool compare_exchange_weak(T*& expc, T* desr, 26 // memory_order s, memory_order f) volatile; 27 // bool compare_exchange_weak(T*& expc, T* desr, 28 // memory_order s, memory_order f); 29 // bool compare_exchange_strong(T*& expc, T* desr, 30 // memory_order s, memory_order f) volatile; 31 // bool compare_exchange_strong(T*& expc, T* desr, 32 // memory_order s, memory_order f); 33 // bool compare_exchange_weak(T*& expc, T* desr, 34 // memory_order m = memory_order_seq_cst) volatile; 35 // bool compare_exchange_weak(T*& expc, T* desr, 36 // memory_order m = memory_order_seq_cst); 37 // bool compare_exchange_strong(T*& expc, T* desr, 38 // memory_order m = memory_order_seq_cst) volatile; 39 // bool compare_exchange_strong(T*& expc, T* desr, 40 // memory_order m = memory_order_seq_cst); 41 // T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile; 42 // T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst); 43 // T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile; 44 // T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst); 45 // 46 // atomic() = default; 47 // constexpr atomic(T* desr); 48 // atomic(const atomic&) = delete; 49 // atomic& operator=(const atomic&) = delete; 50 // atomic& operator=(const atomic&) volatile = delete; 51 // 52 // T* operator=(T*) volatile; 53 // T* operator=(T*); 54 // T* operator++(int) volatile; 55 // T* operator++(int); 56 // T* operator--(int) volatile; 57 // T* operator--(int); 58 // T* operator++() volatile; 59 // T* operator++(); 60 // T* operator--() volatile; 61 // T* operator--(); 62 // T* operator+=(ptrdiff_t op) volatile; 63 // T* operator+=(ptrdiff_t op); 64 // T* operator-=(ptrdiff_t op) volatile; 65 // T* operator-=(ptrdiff_t op); 66 // }; 67 68 #include <atomic> 69 #include <type_traits> 70 #include <cassert> 71 72 template <class A, class T> 73 void 74 do_test() 75 { 76 typedef typename std::remove_pointer<T>::type X; 77 A obj(T(0)); 78 assert(obj == T(0)); 79 std::atomic_init(&obj, T(1)); 80 assert(obj == T(1)); 81 std::atomic_init(&obj, T(2)); 82 assert(obj == T(2)); 83 bool b0 = obj.is_lock_free(); 84 obj.store(T(0)); 85 assert(obj == T(0)); 86 obj.store(T(1), std::memory_order_release); 87 assert(obj == T(1)); 88 assert(obj.load() == T(1)); 89 assert(obj.load(std::memory_order_acquire) == T(1)); 90 assert(obj.exchange(T(2)) == T(1)); 91 assert(obj == T(2)); 92 assert(obj.exchange(T(3), std::memory_order_relaxed) == T(2)); 93 assert(obj == T(3)); 94 T x = obj; 95 assert(obj.compare_exchange_weak(x, T(2)) == true); 96 assert(obj == T(2)); 97 assert(x == T(3)); 98 assert(obj.compare_exchange_weak(x, T(1)) == false); 99 assert(obj == T(2)); 100 assert(x == T(2)); 101 x = T(2); 102 assert(obj.compare_exchange_strong(x, T(1)) == true); 103 assert(obj == T(1)); 104 assert(x == T(2)); 105 assert(obj.compare_exchange_strong(x, T(0)) == false); 106 assert(obj == T(1)); 107 assert(x == T(1)); 108 assert((obj = T(0)) == T(0)); 109 assert(obj == T(0)); 110 obj = T(2*sizeof(X)); 111 assert((obj += std::ptrdiff_t(3)) == T(5*sizeof(X))); 112 assert(obj == T(5*sizeof(X))); 113 assert((obj -= std::ptrdiff_t(3)) == T(2*sizeof(X))); 114 assert(obj == T(2*sizeof(X))); 115 } 116 117 template <class A, class T> 118 void test() 119 { 120 do_test<A, T>(); 121 do_test<volatile A, T>(); 122 } 123 124 int main() 125 { 126 test<std::atomic<int*>, int*>(); 127 } 128
