[libcxx-commits] [libcxx] 06aaf0b - Updated synopsis of <atomic> to match what is implemented
Olivier Giroux via libcxx-commits
libcxx-commits at lists.llvm.org
Mon Jun 1 14:30:24 PDT 2020
Author: Olivier Giroux
Date: 2020-06-01T14:30:13-07:00
New Revision: 06aaf0b3431f29b6debbb96fdd92ada896f336ff
URL: https://github.com/llvm/llvm-project/commit/06aaf0b3431f29b6debbb96fdd92ada896f336ff
DIFF: https://github.com/llvm/llvm-project/commit/06aaf0b3431f29b6debbb96fdd92ada896f336ff.diff
LOG: Updated synopsis of <atomic> to match what is implemented
Added:
Modified:
libcxx/include/atomic
Removed:
################################################################################
diff --git a/libcxx/include/atomic b/libcxx/include/atomic
index c25bea81d6f2..9c2898653788 100644
--- a/libcxx/include/atomic
+++ b/libcxx/include/atomic
@@ -54,60 +54,30 @@ template <class T> T kill_dependency(T y) noexcept;
#define ATOMIC_LLONG_LOCK_FREE unspecified
#define ATOMIC_POINTER_LOCK_FREE unspecified
-// flag type and operations
-
-typedef struct atomic_flag
-{
- bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept;
- bool test_and_set(memory_order m = memory_order_seq_cst) noexcept;
- void clear(memory_order m = memory_order_seq_cst) volatile noexcept;
- void clear(memory_order m = memory_order_seq_cst) noexcept;
- atomic_flag() noexcept = default;
- atomic_flag(const atomic_flag&) = delete;
- atomic_flag& operator=(const atomic_flag&) = delete;
- atomic_flag& operator=(const atomic_flag&) volatile = delete;
-} atomic_flag;
-
-bool
- atomic_flag_test_and_set(volatile atomic_flag* obj) noexcept;
-
-bool
- atomic_flag_test_and_set(atomic_flag* obj) noexcept;
-
-bool
- atomic_flag_test_and_set_explicit(volatile atomic_flag* obj,
- memory_order m) noexcept;
-
-bool
- atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m) noexcept;
-
-void
- atomic_flag_clear(volatile atomic_flag* obj) noexcept;
-
-void
- atomic_flag_clear(atomic_flag* obj) noexcept;
-
-void
- atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m) noexcept;
-
-void
- atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept;
-
-#define ATOMIC_FLAG_INIT see below
-#define ATOMIC_VAR_INIT(value) see below
-
template <class T>
struct atomic
{
+ using value_type = T;
+
static constexpr bool is_always_lock_free;
bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;
- void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
- void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
+
+ atomic() noexcept = default;
+ constexpr atomic(T desr) noexcept;
+ atomic(const atomic&) = delete;
+ atomic& operator=(const atomic&) = delete;
+ atomic& operator=(const atomic&) volatile = delete;
+
T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
T load(memory_order m = memory_order_seq_cst) const noexcept;
operator T() const volatile noexcept;
operator T() const noexcept;
+ void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
+ void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
+ T operator=(T) volatile noexcept;
+ T operator=(T) noexcept;
+
T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;
bool compare_exchange_weak(T& expc, T desr,
@@ -126,27 +96,38 @@ struct atomic
bool compare_exchange_strong(T& expc, T desr,
memory_order m = memory_order_seq_cst) noexcept;
- atomic() noexcept = default;
- constexpr atomic(T desr) noexcept;
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- T operator=(T) volatile noexcept;
- T operator=(T) noexcept;
+ void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept;
+ void wait(T, memory_order = memory_order::seq_cst) const noexcept;
+ void notify_one() volatile noexcept;
+ void notify_one() noexcept;
+ void notify_all() volatile noexcept;
+ void notify_all() noexcept;
};
template <>
struct atomic<integral>
{
+ using value_type = integral;
+
static constexpr bool is_always_lock_free;
bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;
- void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;
- void store(integral desr, memory_order m = memory_order_seq_cst) noexcept;
+
+ atomic() noexcept = default;
+ constexpr atomic(integral desr) noexcept;
+ atomic(const atomic&) = delete;
+ atomic& operator=(const atomic&) = delete;
+ atomic& operator=(const atomic&) volatile = delete;
+
integral load(memory_order m = memory_order_seq_cst) const volatile noexcept;
integral load(memory_order m = memory_order_seq_cst) const noexcept;
operator integral() const volatile noexcept;
operator integral() const noexcept;
+ void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;
+ void store(integral desr, memory_order m = memory_order_seq_cst) noexcept;
+ integral operator=(integral desr) volatile noexcept;
+ integral operator=(integral desr) noexcept;
+
integral exchange(integral desr,
memory_order m = memory_order_seq_cst) volatile noexcept;
integral exchange(integral desr, memory_order m = memory_order_seq_cst) noexcept;
@@ -167,30 +148,17 @@ struct atomic<integral>
bool compare_exchange_strong(integral& expc, integral desr,
memory_order m = memory_order_seq_cst) noexcept;
- integral
- fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
+ integral fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_add(integral op, memory_order m = memory_order_seq_cst) noexcept;
- integral
- fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
+ integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) noexcept;
- integral
- fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
+ integral fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_and(integral op, memory_order m = memory_order_seq_cst) noexcept;
- integral
- fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
+ integral fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexcept;
- integral
- fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
+ integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexcept;
- atomic() noexcept = default;
- constexpr atomic(integral desr) noexcept;
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- integral operator=(integral desr) volatile noexcept;
- integral operator=(integral desr) noexcept;
-
integral operator++(int) volatile noexcept;
integral operator++(int) noexcept;
integral operator--(int) volatile noexcept;
@@ -209,20 +177,39 @@ struct atomic<integral>
integral operator|=(integral op) noexcept;
integral operator^=(integral op) volatile noexcept;
integral operator^=(integral op) noexcept;
+
+ void wait(integral, memory_order = memory_order::seq_cst) const volatile noexcept;
+ void wait(integral, memory_order = memory_order::seq_cst) const noexcept;
+ void notify_one() volatile noexcept;
+ void notify_one() noexcept;
+ void notify_all() volatile noexcept;
+ void notify_all() noexcept;
};
template <class T>
struct atomic<T*>
{
+ using value_type = T*;
+
static constexpr bool is_always_lock_free;
bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;
- void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
- void store(T* desr, memory_order m = memory_order_seq_cst) noexcept;
+
+ atomic() noexcept = default;
+ constexpr atomic(T* desr) noexcept;
+ atomic(const atomic&) = delete;
+ atomic& operator=(const atomic&) = delete;
+ atomic& operator=(const atomic&) volatile = delete;
+
T* load(memory_order m = memory_order_seq_cst) const volatile noexcept;
T* load(memory_order m = memory_order_seq_cst) const noexcept;
operator T*() const volatile noexcept;
operator T*() const noexcept;
+ void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
+ void store(T* desr, memory_order m = memory_order_seq_cst) noexcept;
+ T* operator=(T*) volatile noexcept;
+ T* operator=(T*) noexcept;
+
T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
T* exchange(T* desr, memory_order m = memory_order_seq_cst) noexcept;
bool compare_exchange_weak(T*& expc, T* desr,
@@ -246,14 +233,6 @@ struct atomic<T*>
T* fetch_sub(ptr
diff _t op, memory_order m = memory_order_seq_cst) volatile noexcept;
T* fetch_sub(ptr
diff _t op, memory_order m = memory_order_seq_cst) noexcept;
- atomic() noexcept = default;
- constexpr atomic(T* desr) noexcept;
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
-
- T* operator=(T*) volatile noexcept;
- T* operator=(T*) noexcept;
T* operator++(int) volatile noexcept;
T* operator++(int) noexcept;
T* operator--(int) volatile noexcept;
@@ -266,224 +245,206 @@ struct atomic<T*>
T* operator+=(ptr
diff _t op) noexcept;
T* operator-=(ptr
diff _t op) volatile noexcept;
T* operator-=(ptr
diff _t op) noexcept;
+
+ void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
+ void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
+ void notify_one() volatile noexcept;
+ void notify_one() noexcept;
+ void notify_all() volatile noexcept;
+ void notify_all() noexcept;
};
template <class T>
- bool
- atomic_is_lock_free(const volatile atomic<T>* obj) noexcept;
+ bool atomic_is_lock_free(const volatile atomic<T>* obj) noexcept;
+
+template <class T>
+ bool atomic_is_lock_free(const atomic<T>* obj) noexcept;
+
+template <class T>
+ void atomic_store(volatile atomic<T>* obj, T desr) noexcept;
template <class T>
- bool
- atomic_is_lock_free(const atomic<T>* obj) noexcept;
+ void atomic_store(atomic<T>* obj, T desr) noexcept;
template <class T>
- void
- atomic_init(volatile atomic<T>* obj, T desr) noexcept;
+ void atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
template <class T>
- void
- atomic_init(atomic<T>* obj, T desr) noexcept;
+ void atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
template <class T>
- void
- atomic_store(volatile atomic<T>* obj, T desr) noexcept;
+ T atomic_load(const volatile atomic<T>* obj) noexcept;
template <class T>
- void
- atomic_store(atomic<T>* obj, T desr) noexcept;
+ T atomic_load(const atomic<T>* obj) noexcept;
template <class T>
- void
- atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
+ T atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept;
template <class T>
- void
- atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
+ T atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept;
template <class T>
- T
- atomic_load(const volatile atomic<T>* obj) noexcept;
+ T atomic_exchange(volatile atomic<T>* obj, T desr) noexcept;
template <class T>
- T
- atomic_load(const atomic<T>* obj) noexcept;
+ T atomic_exchange(atomic<T>* obj, T desr) noexcept;
template <class T>
- T
- atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept;
+ T atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
template <class T>
- T
- atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept;
+ T atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
template <class T>
- T
- atomic_exchange(volatile atomic<T>* obj, T desr) noexcept;
+ bool atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexcept;
template <class T>
- T
- atomic_exchange(atomic<T>* obj, T desr) noexcept;
+ bool atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept;
template <class T>
- T
- atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
+ bool atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noexcept;
template <class T>
- T
- atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
+ bool atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept;
template <class T>
- bool
- atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexcept;
+ bool atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
+ T desr,
+ memory_order s, memory_order f) noexcept;
template <class T>
- bool
- atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept;
+ bool atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
+ memory_order s, memory_order f) noexcept;
template <class T>
- bool
- atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noexcept;
+ bool atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj,
+ T* expc, T desr,
+ memory_order s, memory_order f) noexcept;
template <class T>
- bool
- atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept;
+ bool atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc,
+ T desr,
+ memory_order s, memory_order f) noexcept;
template <class T>
- bool
- atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
- T desr,
- memory_order s, memory_order f) noexcept;
+ void atomic_wait(const volatile atomic<T>* obj, T old) noexcept;
template <class T>
- bool
- atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
- memory_order s, memory_order f) noexcept;
+ void atomic_wait(const atomic<T>* obj, T old) noexcept;
template <class T>
- bool
- atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj,
- T* expc, T desr,
- memory_order s, memory_order f) noexcept;
+ void atomic_wait_explicit(const volatile atomic<T>* obj, T old, memory_order m) noexcept;
template <class T>
- bool
- atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc,
- T desr,
- memory_order s, memory_order f) noexcept;
+ void atomic_wait_explicit(const atomic<T>* obj, T old, memory_order m) noexcept;
+
+template <class T>
+ void atomic_one(volatile atomic<T>* obj) noexcept;
+
+template <class T>
+ void atomic_one(atomic<T>* obj) noexcept;
+
+template <class T>
+ void atomic_all(volatile atomic<T>* obj) noexcept;
+
+template <class T>
+ void atomic_all(atomic<T>* obj) noexcept;
template <class Integral>
- Integral
- atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
+ Integral atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
memory_order m) noexcept;
template <class Integral>
- Integral
- atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
+ Integral atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
memory_order m) noexcept;
template <class Integral>
- Integral
- atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
- memory_order m) noexcept;
+ Integral atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
+ memory_order m) noexcept;
+
template <class Integral>
- Integral
- atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
- memory_order m) noexcept;
+ Integral atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
+ memory_order m) noexcept;
+
template <class Integral>
- Integral
- atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op,
- memory_order m) noexcept;
+ Integral atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op,
+ memory_order m) noexcept;
+
template <class Integral>
- Integral
- atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op,
- memory_order m) noexcept;
+ Integral atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op,
+ memory_order m) noexcept;
+
template <class Integral>
- Integral
- atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op,
+ Integral atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op,
memory_order m) noexcept;
+
template <class Integral>
- Integral
- atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op,
+ Integral atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op,
memory_order m) noexcept;
+
template <class Integral>
- Integral
- atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept;
+ Integral atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept;
template <class Integral>
- Integral
- atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op,
- memory_order m) noexcept;
+ Integral atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op,
+ memory_order m) noexcept;
+
template <class Integral>
- Integral
- atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op,
- memory_order m) noexcept;
+ Integral atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op,
+ memory_order m) noexcept;
template <class T>
- T*
- atomic_fetch_add(volatile atomic<T*>* obj, ptr
diff _t op) noexcept;
+ T* atomic_fetch_add(volatile atomic<T*>* obj, ptr
diff _t op) noexcept;
template <class T>
- T*
- atomic_fetch_add(atomic<T*>* obj, ptr
diff _t op) noexcept;
+ T* atomic_fetch_add(atomic<T*>* obj, ptr
diff _t op) noexcept;
template <class T>
- T*
- atomic_fetch_add_explicit(volatile atomic<T*>* obj, ptr
diff _t op,
- memory_order m) noexcept;
+ T* atomic_fetch_add_explicit(volatile atomic<T*>* obj, ptr
diff _t op,
+ memory_order m) noexcept;
+
template <class T>
- T*
- atomic_fetch_add_explicit(atomic<T*>* obj, ptr
diff _t op, memory_order m) noexcept;
+ T* atomic_fetch_add_explicit(atomic<T*>* obj, ptr
diff _t op, memory_order m) noexcept;
template <class T>
- T*
- atomic_fetch_sub(volatile atomic<T*>* obj, ptr
diff _t op) noexcept;
+ T* atomic_fetch_sub(volatile atomic<T*>* obj, ptr
diff _t op) noexcept;
template <class T>
- T*
- atomic_fetch_sub(atomic<T*>* obj, ptr
diff _t op) noexcept;
+ T* atomic_fetch_sub(atomic<T*>* obj, ptr
diff _t op) noexcept;
template <class T>
- T*
- atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptr
diff _t op,
- memory_order m) noexcept;
+ T* atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptr
diff _t op,
+ memory_order m) noexcept;
+
template <class T>
- T*
- atomic_fetch_sub_explicit(atomic<T*>* obj, ptr
diff _t op, memory_order m) noexcept;
+ T* atomic_fetch_sub_explicit(atomic<T*>* obj, ptr
diff _t op, memory_order m) noexcept;
// Atomics for standard typedef types
@@ -516,7 +477,7 @@ typedef atomic<int_fast8_t> atomic_int_fast8_t;
typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
typedef atomic<int_fast16_t> atomic_int_fast16_t;
typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
-typedef atomic<int_fast32_t> atomic_int_fast32_t;
+typedef atomic<int_fast32_t> atomic_int_fast32_t;
typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
typedef atomic<int_fast64_t> atomic_int_fast64_t;
typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
@@ -537,11 +498,71 @@ typedef atomic<ptr
diff _t> atomic_ptr
diff _t;
typedef atomic<intmax_t> atomic_intmax_t;
typedef atomic<uintmax_t> atomic_uintmax_t;
+// flag type and operations
+
+typedef struct atomic_flag
+{
+ atomic_flag() noexcept = default;
+ atomic_flag(const atomic_flag&) = delete;
+ atomic_flag& operator=(const atomic_flag&) = delete;
+ atomic_flag& operator=(const atomic_flag&) volatile = delete;
+
+ bool test(memory_order m = memory_order_seq_cst) volatile noexcept;
+ bool test(memory_order m = memory_order_seq_cst) noexcept;
+ bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept;
+ bool test_and_set(memory_order m = memory_order_seq_cst) noexcept;
+ void clear(memory_order m = memory_order_seq_cst) volatile noexcept;
+ void clear(memory_order m = memory_order_seq_cst) noexcept;
+
+ void wait(bool, memory_order = memory_order::seq_cst) const volatile noexcept;
+ void wait(bool, memory_order = memory_order::seq_cst) const noexcept;
+ void notify_one() volatile noexcept;
+ void notify_one() noexcept;
+ void notify_all() volatile noexcept;
+ void notify_all() noexcept;
+} atomic_flag;
+
+bool atomic_flag_test(volatile atomic_flag* obj) noexcept;
+bool atomic_flag_test(atomic_flag* obj) noexcept;
+bool atomic_flag_test_explicit(volatile atomic_flag* obj,
+ memory_order m) noexcept;
+bool atomic_flag_test_explicit(atomic_flag* obj, memory_order m) noexcept;
+bool atomic_flag_test_and_set(volatile atomic_flag* obj) noexcept;
+bool atomic_flag_test_and_set(atomic_flag* obj) noexcept;
+bool atomic_flag_test_and_set_explicit(volatile atomic_flag* obj,
+ memory_order m) noexcept;
+bool atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m) noexcept;
+void atomic_flag_clear(volatile atomic_flag* obj) noexcept;
+void atomic_flag_clear(atomic_flag* obj) noexcept;
+void atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m) noexcept;
+void atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept;
+
+void atomic_wait(const volatile atomic_flag* obj, T old) noexcept;
+void atomic_wait(const atomic_flag* obj, T old) noexcept;
+void atomic_wait_explicit(const volatile atomic_flag* obj, T old, memory_order m) noexcept;
+void atomic_wait_explicit(const atomic_flag* obj, T old, memory_order m) noexcept;
+void atomic_one(volatile atomic_flag* obj) noexcept;
+void atomic_one(atomic_flag* obj) noexcept;
+void atomic_all(volatile atomic_flag* obj) noexcept;
+void atomic_all(atomic_flag* obj) noexcept;
+
// fences
void atomic_thread_fence(memory_order m) noexcept;
void atomic_signal_fence(memory_order m) noexcept;
+// deprecated
+
+template <class T>
+ void atomic_init(volatile atomic<T>* obj, typename atomic<T>::value_type desr) noexcept;
+
+template <class T>
+ void atomic_init(atomic<T>* obj, typename atomic<T>::value_type desr) noexcept;
+
+#define ATOMIC_VAR_INIT(value) see below
+
+#define ATOMIC_FLAG_INIT see below
+
} // std
*/
More information about the libcxx-commits
mailing list