From Jason Turner

[atomics.syn]

C++20 → C++23 28.2 KB 309 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmppyhg2xp0/{from.md → to.md} +167 -139
tmp/tmppyhg2xp0/{from.md → to.md} RENAMED
@@ -1,260 +1,288 @@
1
- ## Header `<atomic>` synopsis <a id="atomics.syn">[[atomics.syn]]</a>
2
 
3
  ``` cpp
4
  namespace std {
5
  // [atomics.order], order and consistency
6
- enum class memory_order : unspecified;
 
 
 
 
 
 
 
7
  template<class T>
8
- T kill_dependency(T y) noexcept;
 
9
 
10
  // [atomics.lockfree], lock-free property
11
- #define ATOMIC_BOOL_LOCK_FREE unspecified
12
- #define ATOMIC_CHAR_LOCK_FREE unspecified
13
- #define ATOMIC_CHAR8_T_LOCK_FREE unspecified
14
- #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
15
- #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
16
- #define ATOMIC_WCHAR_T_LOCK_FREE unspecified
17
- #define ATOMIC_SHORT_LOCK_FREE unspecified
18
- #define ATOMIC_INT_LOCK_FREE unspecified
19
- #define ATOMIC_LONG_LOCK_FREE unspecified
20
- #define ATOMIC_LLONG_LOCK_FREE unspecified
21
- #define ATOMIC_POINTER_LOCK_FREE unspecified
22
 
 
23
  // [atomics.ref.generic], class template atomic_ref
24
- template<class T> struct atomic_ref;
25
  // [atomics.ref.pointer], partial specialization for pointers
26
- template<class T> struct atomic_ref<T*>;
27
 
28
  // [atomics.types.generic], class template atomic
29
- template<class T> struct atomic;
30
  // [atomics.types.pointer], partial specialization for pointers
31
- template<class T> struct atomic<T*>;
32
 
33
  // [atomics.nonmembers], non-member functions
34
  template<class T>
35
- bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;
36
  template<class T>
37
- bool atomic_is_lock_free(const atomic<T>*) noexcept;
38
  template<class T>
39
- void atomic_store(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
 
40
  template<class T>
41
- void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept;
42
  template<class T>
43
- void atomic_store_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
 
44
  memory_order) noexcept;
45
  template<class T>
46
- void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type,
47
  memory_order) noexcept;
48
  template<class T>
49
- T atomic_load(const volatile atomic<T>*) noexcept;
50
  template<class T>
51
- T atomic_load(const atomic<T>*) noexcept;
52
  template<class T>
53
- T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;
54
  template<class T>
55
- T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;
56
  template<class T>
57
- T atomic_exchange(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
 
58
  template<class T>
59
- T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept;
60
  template<class T>
61
- T atomic_exchange_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
 
62
  memory_order) noexcept;
63
  template<class T>
64
- T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type,
65
  memory_order) noexcept;
66
  template<class T>
67
- bool atomic_compare_exchange_weak(volatile atomic<T>*,
68
  typename atomic<T>::value_type*,
69
  typename atomic<T>::value_type) noexcept;
70
  template<class T>
71
- bool atomic_compare_exchange_weak(atomic<T>*,
72
  typename atomic<T>::value_type*,
73
  typename atomic<T>::value_type) noexcept;
74
  template<class T>
75
- bool atomic_compare_exchange_strong(volatile atomic<T>*,
76
  typename atomic<T>::value_type*,
77
  typename atomic<T>::value_type) noexcept;
78
  template<class T>
79
- bool atomic_compare_exchange_strong(atomic<T>*,
80
  typename atomic<T>::value_type*,
81
  typename atomic<T>::value_type) noexcept;
82
  template<class T>
83
- bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*,
84
  typename atomic<T>::value_type*,
85
  typename atomic<T>::value_type,
86
  memory_order, memory_order) noexcept;
87
  template<class T>
88
- bool atomic_compare_exchange_weak_explicit(atomic<T>*,
89
  typename atomic<T>::value_type*,
90
  typename atomic<T>::value_type,
91
  memory_order, memory_order) noexcept;
92
  template<class T>
93
- bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*,
94
  typename atomic<T>::value_type*,
95
  typename atomic<T>::value_type,
96
  memory_order, memory_order) noexcept;
97
  template<class T>
98
- bool atomic_compare_exchange_strong_explicit(atomic<T>*,
99
  typename atomic<T>::value_type*,
100
  typename atomic<T>::value_type,
101
  memory_order, memory_order) noexcept;
102
 
103
  template<class T>
104
- T atomic_fetch_add(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
 
105
  template<class T>
106
- T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;
107
  template<class T>
108
- T atomic_fetch_add_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
 
109
  memory_order) noexcept;
110
  template<class T>
111
- T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type,
112
  memory_order) noexcept;
113
  template<class T>
114
- T atomic_fetch_sub(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
 
115
  template<class T>
116
- T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;
117
  template<class T>
118
- T atomic_fetch_sub_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
 
119
  memory_order) noexcept;
120
  template<class T>
121
- T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,
122
  memory_order) noexcept;
123
  template<class T>
124
- T atomic_fetch_and(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
 
125
  template<class T>
126
- T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept;
127
  template<class T>
128
- T atomic_fetch_and_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
 
129
  memory_order) noexcept;
130
  template<class T>
131
- T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type,
132
  memory_order) noexcept;
133
  template<class T>
134
- T atomic_fetch_or(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
 
135
  template<class T>
136
- T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept;
137
  template<class T>
138
- T atomic_fetch_or_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
 
139
  memory_order) noexcept;
140
  template<class T>
141
- T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type,
142
  memory_order) noexcept;
143
  template<class T>
144
- T atomic_fetch_xor(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
 
145
  template<class T>
146
- T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;
147
  template<class T>
148
- T atomic_fetch_xor_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
 
149
  memory_order) noexcept;
150
  template<class T>
151
- T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type,
152
  memory_order) noexcept;
153
 
154
  template<class T>
155
- void atomic_wait(const volatile atomic<T>*, typename atomic<T>::value_type);
 
156
  template<class T>
157
- void atomic_wait(const atomic<T>*, typename atomic<T>::value_type);
158
  template<class T>
159
- void atomic_wait_explicit(const volatile atomic<T>*, typename atomic<T>::value_type,
160
- memory_order);
 
161
  template<class T>
162
- void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type,
163
- memory_order);
164
  template<class T>
165
- void atomic_notify_one(volatile atomic<T>*);
166
  template<class T>
167
- void atomic_notify_one(atomic<T>*);
168
  template<class T>
169
- void atomic_notify_all(volatile atomic<T>*);
170
  template<class T>
171
- void atomic_notify_all(atomic<T>*);
172
 
173
  // [atomics.alias], type aliases
174
- using atomic_bool = atomic<bool>;
175
- using atomic_char = atomic<char>;
176
- using atomic_schar = atomic<signed char>;
177
- using atomic_uchar = atomic<unsigned char>;
178
- using atomic_short = atomic<short>;
179
- using atomic_ushort = atomic<unsigned short>;
180
- using atomic_int = atomic<int>;
181
- using atomic_uint = atomic<unsigned int>;
182
- using atomic_long = atomic<long>;
183
- using atomic_ulong = atomic<unsigned long>;
184
- using atomic_llong = atomic<long long>;
185
- using atomic_ullong = atomic<unsigned long long>;
186
- using atomic_char8_t = atomic<char8_t>;
187
- using atomic_char16_t = atomic<char16_t>;
188
- using atomic_char32_t = atomic<char32_t>;
189
- using atomic_wchar_t = atomic<wchar_t>;
190
 
191
- using atomic_int8_t = atomic<int8_t>;
192
- using atomic_uint8_t = atomic<uint8_t>;
193
- using atomic_int16_t = atomic<int16_t>;
194
- using atomic_uint16_t = atomic<uint16_t>;
195
- using atomic_int32_t = atomic<int32_t>;
196
- using atomic_uint32_t = atomic<uint32_t>;
197
- using atomic_int64_t = atomic<int64_t>;
198
- using atomic_uint64_t = atomic<uint64_t>;
199
 
200
- using atomic_int_least8_t = atomic<int_least8_t>;
201
- using atomic_uint_least8_t = atomic<uint_least8_t>;
202
- using atomic_int_least16_t = atomic<int_least16_t>;
203
- using atomic_uint_least16_t = atomic<uint_least16_t>;
204
- using atomic_int_least32_t = atomic<int_least32_t>;
205
- using atomic_uint_least32_t = atomic<uint_least32_t>;
206
- using atomic_int_least64_t = atomic<int_least64_t>;
207
- using atomic_uint_least64_t = atomic<uint_least64_t>;
208
 
209
- using atomic_int_fast8_t = atomic<int_fast8_t>;
210
- using atomic_uint_fast8_t = atomic<uint_fast8_t>;
211
- using atomic_int_fast16_t = atomic<int_fast16_t>;
212
- using atomic_uint_fast16_t = atomic<uint_fast16_t>;
213
- using atomic_int_fast32_t = atomic<int_fast32_t>;
214
- using atomic_uint_fast32_t = atomic<uint_fast32_t>;
215
- using atomic_int_fast64_t = atomic<int_fast64_t>;
216
- using atomic_uint_fast64_t = atomic<uint_fast64_t>;
217
 
218
- using atomic_intptr_t = atomic<intptr_t>;
219
- using atomic_uintptr_t = atomic<uintptr_t>;
220
- using atomic_size_t = atomic<size_t>;
221
- using atomic_ptrdiff_t = atomic<ptrdiff_t>;
222
- using atomic_intmax_t = atomic<intmax_t>;
223
- using atomic_uintmax_t = atomic<uintmax_t>;
224
 
225
  using atomic_signed_lock_free = see below;
226
  using atomic_unsigned_lock_free = see below;
227
 
228
  // [atomics.flag], flag type and operations
229
- struct atomic_flag;
230
 
231
- bool atomic_flag_test(const volatile atomic_flag*) noexcept;
232
- bool atomic_flag_test(const atomic_flag*) noexcept;
233
- bool atomic_flag_test_explicit(const volatile atomic_flag*, memory_order) noexcept;
234
- bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept;
235
- bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
236
- bool atomic_flag_test_and_set(atomic_flag*) noexcept;
237
- bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept;
238
- bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
239
- void atomic_flag_clear(volatile atomic_flag*) noexcept;
240
- void atomic_flag_clear(atomic_flag*) noexcept;
241
- void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
242
- void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;
 
 
243
 
244
- void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;
245
- void atomic_flag_wait(const atomic_flag*, bool) noexcept;
246
- void atomic_flag_wait_explicit(const volatile atomic_flag*,
247
  bool, memory_order) noexcept;
248
- void atomic_flag_wait_explicit(const atomic_flag*,
249
  bool, memory_order) noexcept;
250
- void atomic_flag_notify_one(volatile atomic_flag*) noexcept;
251
- void atomic_flag_notify_one(atomic_flag*) noexcept;
252
- void atomic_flag_notify_all(volatile atomic_flag*) noexcept;
253
- void atomic_flag_notify_all(atomic_flag*) noexcept;
 
254
 
255
  // [atomics.fences], fences
256
- extern "C" void atomic_thread_fence(memory_order) noexcept;
257
- extern "C" void atomic_signal_fence(memory_order) noexcept;
258
  }
259
  ```
260
 
 
1
+ ### Header `<atomic>` synopsis <a id="atomics.syn">[[atomics.syn]]</a>
2
 
3
  ``` cpp
4
  namespace std {
5
  // [atomics.order], order and consistency
6
+ enum class memory_order : unspecified; // freestanding
7
+ inline constexpr memory_order memory_order_relaxed = memory_order::relaxed; // freestanding
8
+ inline constexpr memory_order memory_order_consume = memory_order::consume; // freestanding
9
+ inline constexpr memory_order memory_order_acquire = memory_order::acquire; // freestanding
10
+ inline constexpr memory_order memory_order_release = memory_order::release; // freestanding
11
+ inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel; // freestanding
12
+ inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst; // freestanding
13
+
14
  template<class T>
15
+ T kill_dependency(T y) noexcept; // freestanding
16
+ }
17
 
18
  // [atomics.lockfree], lock-free property
19
+ #define ATOMIC_BOOL_LOCK_FREE unspecified // freestanding
20
+ #define ATOMIC_CHAR_LOCK_FREE unspecified // freestanding
21
+ #define ATOMIC_CHAR8_T_LOCK_FREE unspecified // freestanding
22
+ #define ATOMIC_CHAR16_T_LOCK_FREE unspecified // freestanding
23
+ #define ATOMIC_CHAR32_T_LOCK_FREE unspecified // freestanding
24
+ #define ATOMIC_WCHAR_T_LOCK_FREE unspecified // freestanding
25
+ #define ATOMIC_SHORT_LOCK_FREE unspecified // freestanding
26
+ #define ATOMIC_INT_LOCK_FREE unspecified // freestanding
27
+ #define ATOMIC_LONG_LOCK_FREE unspecified // freestanding
28
+ #define ATOMIC_LLONG_LOCK_FREE unspecified // freestanding
29
+ #define ATOMIC_POINTER_LOCK_FREE unspecified // freestanding
30
 
31
+ namespace std {
32
  // [atomics.ref.generic], class template atomic_ref
33
+ template<class T> struct atomic_ref; // freestanding
34
  // [atomics.ref.pointer], partial specialization for pointers
35
+ template<class T> struct atomic_ref<T*>; // freestanding
36
 
37
  // [atomics.types.generic], class template atomic
38
+ template<class T> struct atomic; // freestanding
39
  // [atomics.types.pointer], partial specialization for pointers
40
+ template<class T> struct atomic<T*>; // freestanding
41
 
42
  // [atomics.nonmembers], non-member functions
43
  template<class T>
44
+ bool atomic_is_lock_free(const volatile atomic<T>*) noexcept; // freestanding
45
  template<class T>
46
+ bool atomic_is_lock_free(const atomic<T>*) noexcept; // freestanding
47
  template<class T>
48
+ void atomic_store(volatile atomic<T>*, // freestanding
49
+ typename atomic<T>::value_type) noexcept;
50
  template<class T>
51
+ void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding
52
  template<class T>
53
+ void atomic_store_explicit(volatile atomic<T>*, // freestanding
54
+ typename atomic<T>::value_type,
55
  memory_order) noexcept;
56
  template<class T>
57
+ void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding
58
  memory_order) noexcept;
59
  template<class T>
60
+ T atomic_load(const volatile atomic<T>*) noexcept; // freestanding
61
  template<class T>
62
+ T atomic_load(const atomic<T>*) noexcept; // freestanding
63
  template<class T>
64
+ T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept; // freestanding
65
  template<class T>
66
+ T atomic_load_explicit(const atomic<T>*, memory_order) noexcept; // freestanding
67
  template<class T>
68
+ T atomic_exchange(volatile atomic<T>*, // freestanding
69
+ typename atomic<T>::value_type) noexcept;
70
  template<class T>
71
+ T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding
72
  template<class T>
73
+ T atomic_exchange_explicit(volatile atomic<T>*, // freestanding
74
+ typename atomic<T>::value_type,
75
  memory_order) noexcept;
76
  template<class T>
77
+ T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding
78
  memory_order) noexcept;
79
  template<class T>
80
+ bool atomic_compare_exchange_weak(volatile atomic<T>*, // freestanding
81
  typename atomic<T>::value_type*,
82
  typename atomic<T>::value_type) noexcept;
83
  template<class T>
84
+ bool atomic_compare_exchange_weak(atomic<T>*, // freestanding
85
  typename atomic<T>::value_type*,
86
  typename atomic<T>::value_type) noexcept;
87
  template<class T>
88
+ bool atomic_compare_exchange_strong(volatile atomic<T>*, // freestanding
89
  typename atomic<T>::value_type*,
90
  typename atomic<T>::value_type) noexcept;
91
  template<class T>
92
+ bool atomic_compare_exchange_strong(atomic<T>*, // freestanding
93
  typename atomic<T>::value_type*,
94
  typename atomic<T>::value_type) noexcept;
95
  template<class T>
96
+ bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*, // freestanding
97
  typename atomic<T>::value_type*,
98
  typename atomic<T>::value_type,
99
  memory_order, memory_order) noexcept;
100
  template<class T>
101
+ bool atomic_compare_exchange_weak_explicit(atomic<T>*, // freestanding
102
  typename atomic<T>::value_type*,
103
  typename atomic<T>::value_type,
104
  memory_order, memory_order) noexcept;
105
  template<class T>
106
+ bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*, // freestanding
107
  typename atomic<T>::value_type*,
108
  typename atomic<T>::value_type,
109
  memory_order, memory_order) noexcept;
110
  template<class T>
111
+ bool atomic_compare_exchange_strong_explicit(atomic<T>*, // freestanding
112
  typename atomic<T>::value_type*,
113
  typename atomic<T>::value_type,
114
  memory_order, memory_order) noexcept;
115
 
116
  template<class T>
117
+ T atomic_fetch_add(volatile atomic<T>*, // freestanding
118
+ typename atomic<T>::difference_type) noexcept;
119
  template<class T>
120
+ T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept; // freestanding
121
  template<class T>
122
+ T atomic_fetch_add_explicit(volatile atomic<T>*, // freestanding
123
+ typename atomic<T>::difference_type,
124
  memory_order) noexcept;
125
  template<class T>
126
+ T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type, // freestanding
127
  memory_order) noexcept;
128
  template<class T>
129
+ T atomic_fetch_sub(volatile atomic<T>*, // freestanding
130
+ typename atomic<T>::difference_type) noexcept;
131
  template<class T>
132
+ T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept; // freestanding
133
  template<class T>
134
+ T atomic_fetch_sub_explicit(volatile atomic<T>*, // freestanding
135
+ typename atomic<T>::difference_type,
136
  memory_order) noexcept;
137
  template<class T>
138
+ T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type, // freestanding
139
  memory_order) noexcept;
140
  template<class T>
141
+ T atomic_fetch_and(volatile atomic<T>*, // freestanding
142
+ typename atomic<T>::value_type) noexcept;
143
  template<class T>
144
+ T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding
145
  template<class T>
146
+ T atomic_fetch_and_explicit(volatile atomic<T>*, // freestanding
147
+ typename atomic<T>::value_type,
148
  memory_order) noexcept;
149
  template<class T>
150
+ T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding
151
  memory_order) noexcept;
152
  template<class T>
153
+ T atomic_fetch_or(volatile atomic<T>*, // freestanding
154
+ typename atomic<T>::value_type) noexcept;
155
  template<class T>
156
+ T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding
157
  template<class T>
158
+ T atomic_fetch_or_explicit(volatile atomic<T>*, // freestanding
159
+ typename atomic<T>::value_type,
160
  memory_order) noexcept;
161
  template<class T>
162
+ T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding
163
  memory_order) noexcept;
164
  template<class T>
165
+ T atomic_fetch_xor(volatile atomic<T>*, // freestanding
166
+ typename atomic<T>::value_type) noexcept;
167
  template<class T>
168
+ T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding
169
  template<class T>
170
+ T atomic_fetch_xor_explicit(volatile atomic<T>*, // freestanding
171
+ typename atomic<T>::value_type,
172
  memory_order) noexcept;
173
  template<class T>
174
+ T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding
175
  memory_order) noexcept;
176
 
177
  template<class T>
178
+ void atomic_wait(const volatile atomic<T>*, // freestanding
179
+ typename atomic<T>::value_type) noexcept;
180
  template<class T>
181
+ void atomic_wait(const atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding
182
  template<class T>
183
+ void atomic_wait_explicit(const volatile atomic<T>*, // freestanding
184
+ typename atomic<T>::value_type,
185
+ memory_order) noexcept;
186
  template<class T>
187
+ void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type, // freestanding
188
+ memory_order) noexcept;
189
  template<class T>
190
+ void atomic_notify_one(volatile atomic<T>*) noexcept; // freestanding
191
  template<class T>
192
+ void atomic_notify_one(atomic<T>*) noexcept; // freestanding
193
  template<class T>
194
+ void atomic_notify_all(volatile atomic<T>*) noexcept; // freestanding
195
  template<class T>
196
+ void atomic_notify_all(atomic<T>*) noexcept; // freestanding
197
 
198
  // [atomics.alias], type aliases
199
+ using atomic_bool = atomic<bool>; // freestanding
200
+ using atomic_char = atomic<char>; // freestanding
201
+ using atomic_schar = atomic<signed char>; // freestanding
202
+ using atomic_uchar = atomic<unsigned char>; // freestanding
203
+ using atomic_short = atomic<short>; // freestanding
204
+ using atomic_ushort = atomic<unsigned short>; // freestanding
205
+ using atomic_int = atomic<int>; // freestanding
206
+ using atomic_uint = atomic<unsigned int>; // freestanding
207
+ using atomic_long = atomic<long>; // freestanding
208
+ using atomic_ulong = atomic<unsigned long>; // freestanding
209
+ using atomic_llong = atomic<long long>; // freestanding
210
+ using atomic_ullong = atomic<unsigned long long>; // freestanding
211
+ using atomic_char8_t = atomic<char8_t>; // freestanding
212
+ using atomic_char16_t = atomic<char16_t>; // freestanding
213
+ using atomic_char32_t = atomic<char32_t>; // freestanding
214
+ using atomic_wchar_t = atomic<wchar_t>; // freestanding
215
 
216
+ using atomic_int8_t = atomic<int8_t>; // freestanding
217
+ using atomic_uint8_t = atomic<uint8_t>; // freestanding
218
+ using atomic_int16_t = atomic<int16_t>; // freestanding
219
+ using atomic_uint16_t = atomic<uint16_t>; // freestanding
220
+ using atomic_int32_t = atomic<int32_t>; // freestanding
221
+ using atomic_uint32_t = atomic<uint32_t>; // freestanding
222
+ using atomic_int64_t = atomic<int64_t>; // freestanding
223
+ using atomic_uint64_t = atomic<uint64_t>; // freestanding
224
 
225
+ using atomic_int_least8_t = atomic<int_least8_t>; // freestanding
226
+ using atomic_uint_least8_t = atomic<uint_least8_t>; // freestanding
227
+ using atomic_int_least16_t = atomic<int_least16_t>; // freestanding
228
+ using atomic_uint_least16_t = atomic<uint_least16_t>; // freestanding
229
+ using atomic_int_least32_t = atomic<int_least32_t>; // freestanding
230
+ using atomic_uint_least32_t = atomic<uint_least32_t>; // freestanding
231
+ using atomic_int_least64_t = atomic<int_least64_t>; // freestanding
232
+ using atomic_uint_least64_t = atomic<uint_least64_t>; // freestanding
233
 
234
+ using atomic_int_fast8_t = atomic<int_fast8_t>; // freestanding
235
+ using atomic_uint_fast8_t = atomic<uint_fast8_t>; // freestanding
236
+ using atomic_int_fast16_t = atomic<int_fast16_t>; // freestanding
237
+ using atomic_uint_fast16_t = atomic<uint_fast16_t>; // freestanding
238
+ using atomic_int_fast32_t = atomic<int_fast32_t>; // freestanding
239
+ using atomic_uint_fast32_t = atomic<uint_fast32_t>; // freestanding
240
+ using atomic_int_fast64_t = atomic<int_fast64_t>; // freestanding
241
+ using atomic_uint_fast64_t = atomic<uint_fast64_t>; // freestanding
242
 
243
+ using atomic_intptr_t = atomic<intptr_t>; // freestanding
244
+ using atomic_uintptr_t = atomic<uintptr_t>; // freestanding
245
+ using atomic_size_t = atomic<size_t>; // freestanding
246
+ using atomic_ptrdiff_t = atomic<ptrdiff_t>; // freestanding
247
+ using atomic_intmax_t = atomic<intmax_t>; // freestanding
248
+ using atomic_uintmax_t = atomic<uintmax_t>; // freestanding
249
 
250
  using atomic_signed_lock_free = see below;
251
  using atomic_unsigned_lock_free = see below;
252
 
253
  // [atomics.flag], flag type and operations
254
+ struct atomic_flag; // freestanding
255
 
256
+ bool atomic_flag_test(const volatile atomic_flag*) noexcept; // freestanding
257
+ bool atomic_flag_test(const atomic_flag*) noexcept; // freestanding
258
+ bool atomic_flag_test_explicit(const volatile atomic_flag*, // freestanding
259
+ memory_order) noexcept;
260
+ bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept; // freestanding
261
+ bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept; // freestanding
262
+ bool atomic_flag_test_and_set(atomic_flag*) noexcept; // freestanding
263
+ bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, // freestanding
264
+ memory_order) noexcept;
265
+ bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept; // freestanding
266
+ void atomic_flag_clear(volatile atomic_flag*) noexcept; // freestanding
267
+ void atomic_flag_clear(atomic_flag*) noexcept; // freestanding
268
+ void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept; // freestanding
269
+ void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept; // freestanding
270
 
271
+ void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept; // freestanding
272
+ void atomic_flag_wait(const atomic_flag*, bool) noexcept; // freestanding
273
+ void atomic_flag_wait_explicit(const volatile atomic_flag*, // freestanding
274
  bool, memory_order) noexcept;
275
+ void atomic_flag_wait_explicit(const atomic_flag*, // freestanding
276
  bool, memory_order) noexcept;
277
+ void atomic_flag_notify_one(volatile atomic_flag*) noexcept; // freestanding
278
+ void atomic_flag_notify_one(atomic_flag*) noexcept; // freestanding
279
+ void atomic_flag_notify_all(volatile atomic_flag*) noexcept; // freestanding
280
+ void atomic_flag_notify_all(atomic_flag*) noexcept; // freestanding
281
+ #define ATOMIC_FLAG_INIT see belownc // freestanding
282
 
283
  // [atomics.fences], fences
284
+ extern "C" void atomic_thread_fence(memory_order) noexcept; // freestanding
285
+ extern "C" void atomic_signal_fence(memory_order) noexcept; // freestanding
286
  }
287
  ```
288