Debian Codegraph @

headers/atomic

raw
1 /* Copyright (C) 2015 Povilas Kanapickas <[email protected]>
2
3 This file is part of cppreference-doc
4
5 This work is licensed under the Creative Commons Attribution-ShareAlike 3.0
6 Unported License. To view a copy of this license, visit
7 http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
8 Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
9
10 Permission is granted to copy, distribute and/or modify this document
11 under the terms of the GNU Free Documentation License, Version 1.3 or
12 any later version published by the Free Software Foundation; with no
13 Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
14 */
15
16 #ifndef CPPREFERENCE_ATOMIC_H
17 #define CPPREFERENCE_ATOMIC_H
18
19 namespace std {
20
21 #if CPPREFERENCE_STDVER>= 2011
22
23 enum memory_order {
24 memory_order_relaxed,
25 memory_order_consume,
26 memory_order_acquire,
27 memory_order_release,
28 memory_order_acq_rel,
29 memory_order_seq_cst
30 };
31
32 template<class T>
33 struct atomic {
34 atomic() = default;
35 constexpr atomic(T desired);
36 atomic(const atomic&) = delete;
37
38 T operator=(T desired);
39 T operator=(T desired) volatile;
40
41 atomic& operator=(const atomic&) = delete;
42 atomic& operator=(const atomic&) volatile = delete;
43
44 bool is_lock_free() const;
45 bool is_lock_free() const volatile;
46
47 void store(T desired, std::memory_order order = std::memory_order_seq_cst);
48 void store(T desired, std::memory_order order = std::memory_order_seq_cst) volatile;
49
50 T load(std::memory_order order = std::memory_order_seq_cst) const;
51 T load(std::memory_order order = std::memory_order_seq_cst) const volatile;
52
53 operator T() const;
54 operator T() const volatile;
55
56 T exchange(T desired, std::memory_order order = std::memory_order_seq_cst);
57 T exchange(T desired, std::memory_order order = std::memory_order_seq_cst) volatile;
58
59 bool compare_exchange_weak(T& expected, T desired,
60 std::memory_order success,
61 std::memory_order failure);
62
63 bool compare_exchange_weak(T& expected, T desired,
64
65 std::memory_order success,
66 std::memory_order failure) volatile;
67
68 bool compare_exchange_weak(T& expected, T desired,
69 std::memory_order order =
70 std::memory_order_seq_cst);
71
72 bool compare_exchange_weak(T& expected, T desired,
73 std::memory_order order =
74 std::memory_order_seq_cst) volatile;
75
76 bool compare_exchange_strong(T& expected, T desired,
77 std::memory_order success,
78 std::memory_order failure);
79
80 bool compare_exchange_strong(T& expected, T desired,
81 std::memory_order success,
82 std::memory_order failure) volatile;
83
84 bool compare_exchange_strong(T& expected, T desired,
85 std::memory_order order =
86 std::memory_order_seq_cst);
87
88 bool compare_exchange_strong(T& expected, T desired,
89 std::memory_order order =
90 std::memory_order_seq_cst) volatile;
91
92 // member of atomic<Integral>
93 T fetch_add(T arg,
94 memory_order = std::memory_order_seq_cst);
95 T fetch_add(T arg,
96 memory_order = std::memory_order_seq_cst) volatile;
97
98 // member of atomic<T*>
99 T* fetch_add(std::ptrdiff_t arg,
100 memory_order = std::memory_order_seq_cst);
101 T* fetch_add(std::ptrdiff_t arg,
102 memory_order = std::memory_order_seq_cst) volatile;
103
104 // member of atomic<Integral>
105 T fetch_sub(T arg,
106 memory_order = std::memory_order_seq_cst);
107 T fetch_sub(T arg,
108 memory_order = std::memory_order_seq_cst) volatile;
109
110 // member of atomic<T*>
111 T* fetch_sub(std::ptrdiff_t arg,
112 memory_order = std::memory_order_seq_cst);
113 T* fetch_sub(std::ptrdiff_t arg,
114 memory_order = std::memory_order_seq_cst) volatile;
115
116 // member of atomic<Integral>
117 T fetch_and(T arg,
118 memory_order = std::memory_order_seq_cst);
119 T fetch_and(T arg,
120 memory_order = std::memory_order_seq_cst) volatile;
121
122 // member of atomic<Integral>
123 T fetch_or(T arg,
124 memory_order = std::memory_order_seq_cst);
125 T fetch_or(T arg,
126 memory_order = std::memory_order_seq_cst) volatile;
127
128 // member of atomic<Integral>
129 T fetch_xor(T arg,
130 memory_xorder = std::memory_xorder_seq_cst);
131 T fetch_xor(T arg,
132 memory_xorder = std::memory_xorder_seq_cst) volatile;
133
134 // member of atomic<Integral>
135 T operator++();
136 T operator++() volatile;
137 T operator++(int);
138 T operator++(int) volatile;
139 T operator--();
140 T operator--() volatile;
141 T operator--(int);
142 T operator--(int) volatile;
143 T operator+=(T arg);
144 T operator+=(T arg) volatile;
145 T operator-=(T arg);
146 T operator-=(T arg) volatile;
147 T operator&=(T arg);
148 T operator&=(T arg) volatile;
149 T operator|=(T arg);
150 T operator|=(T arg) volatile;
151 T operator^=(T arg);
152 T operator^=(T arg) volatile;
153
154 // member of atomic<T*>
155 T* operator++();
156 T* operator++() volatile;
157 T* operator++(int);
158 T* operator++(int) volatile;
159 T* operator--();
160 T* operator--() volatile;
161 T* operator--(int);
162 T* operator--(int) volatile;
163 T* operator+=(std::ptrdiff_t arg);
164 T* operator+=(std::ptrdiff_t arg) volatile;
165 T* operator-=(std::ptrdiff_t arg);
166 T* operator-=(std::ptrdiff_t arg) volatile;
167 };
168
169 typedef atomic<bool> atomic_bool;
170 typedef atomic<char> atomic_char;
171 typedef atomic<signed char> atomic_schar;
172 typedef atomic<unsigned char> atomic_uchar;
173 typedef atomic<short> atomic_short;
174 typedef atomic<unsigned short> atomic_ushort;
175 typedef atomic<int> atomic_int;
176 typedef atomic<unsigned int> atomic_uint;
177 typedef atomic<long> atomic_long;
178 typedef atomic<unsigned long> atomic_ulong;
179 typedef atomic<long long> atomic_llong;
180 typedef atomic<unsigned long long> atomic_ullong;
181 typedef atomic<char16_t> atomic_char16_t;
182 typedef atomic<char32_t> atomic_char32_t;
183 typedef atomic<wchar_t> atomic_wchar_t;
184
185 typedef atomic<int_least8_t> atomic_int_least8_t;
186 typedef atomic<uint_least8_t> atomic_uint_least8_t;
187 typedef atomic<int_least16_t> atomic_int_least16_t;
188 typedef atomic<uint_least16_t> atomic_uint_least16_t;
189 typedef atomic<int_least32_t> atomic_int_least32_t;
190 typedef atomic<uint_least32_t> atomic_uint_least32_t;
191 typedef atomic<int_least64_t> atomic_int_least64_t;
192 typedef atomic<uint_least64_t> atomic_uint_least64_t;
193
194 typedef atomic<int_fast8_t> atomic_int_fast8_t;
195 typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
196 typedef atomic<int_fast16_t> atomic_int_fast16_t;
197 typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
198 typedef atomic<int_fast32_t> atomic_int_fast32_t;
199 typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
200 typedef atomic<int_fast64_t> atomic_int_fast64_t;
201 typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
202
203 typedef atomic<intptr_t> atomic_intptr_t;
204 typedef atomic<uintptr_t> atomic_uintptr_t;
205 typedef atomic<size_t> atomic_size_t;
206 typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
207 typedef atomic<intmax_t> atomic_intmax_t;
208 typedef atomic<uintmax_t> atomic_uintmax_t;
209
210 template<class T>
211 bool atomic_is_lock_free(const volatile std::atomic<T>* obj);
212 template<class T>
213 bool atomic_is_lock_free(const std::atomic<T>* obj);
214
215 template<class T>
216 void atomic_store(std::atomic<T>* obj, T desr);
217 template<class T>
218 void atomic_store(volatile std::atomic<T>* obj, T desr);
219
220 template<class T>
221 void atomic_store_explicit(std::atomic<T>* obj, T desr,
222 std::memory_order order);
223 template<class T>
224 void atomic_store_explicit(volatile std::atomic<T>* obj, T desr,
225 std::memory_order order);
226
227 template<class T>
228 T atomic_load(const std::atomic<T>* obj);
229 template<class T>
230 T atomic_load(const volatile std::atomic<T>* obj);
231
232 template<class T>
233 T atomic_load_explicit(const std::atomic<T>* obj,
234 std::memory_order order);
235 template<class T>
236 T atomic_load_explicit(const volatile std::atomic<T>* obj,
237 std::memory_order order);
238
239 template<class T>
240 T atomic_exchange(std::atomic<T>* obj, T desr);
241 template<class T>
242 T atomic_exchange(volatile std::atomic<T>* obj, T desr);
243
244 template<class T>
245 T atomic_exchange_explicit(std::atomic<T>* obj, T desr,
246 std::memory_order order);
247 template<class T>
248 T atomic_exchange_explicit(volatile std::atomic<T>* obj, T desr,
249 std::memory_order order);
250
251 template<class T>
252 bool atomic_compare_exchange_weak(std::atomic<T>* obj,
253 T* expected, T desired);
254 template<class T>
255 bool atomic_compare_exchange_weak(volatile std::atomic<T>* obj,
256 T* expected, T desired);
257
258 template<class T>
259 bool atomic_compare_exchange_strong(std::atomic<T>* obj,
260 T* expected, T desired);
261 template<class T>
262 bool atomic_compare_exchange_strong(volatile std::atomic<T>* obj,
263 T* expected, T desired);
264
265 template<class T>
266 bool atomic_compare_exchange_weak_explicit(std::atomic<T>* obj,
267 T* expected, T desired,
268 std::memory_order succ,
269 std::memory_order fail);
270 template<class T>
271 bool atomic_compare_exchange_weak_explicit(volatile std::atomic<T>* obj,
272 T* expected, T desired,
273 std::memory_order succ,
274 std::memory_order fail);
275
276 template<class T>
277 bool atomic_compare_exchange_strong_explicit(std::atomic<T>* obj,
278 T* expected, T desired,
279 std::memory_order succ,
280 std::memory_order fail);
281 template<class T>
282 bool atomic_compare_exchange_strong_explicit(volatile std::atomic<T>* obj,
283 T* expected, T desired,
284 std::memory_order succ,
285 std::memory_order fail);
286
287 template<class Integral>
288 Integral atomic_fetch_add(std::atomic<Integral>* obj, Integral arg);
289 template<class Integral>
290 Integral atomic_fetch_add(volatile std::atomic<Integral>* obj, Integral arg);
291
292 template<class Integral>
293 Integral atomic_fetch_add_explicit(std::atomic<Integral>* obj, Integral arg,
294 std::memory_order order);
295 template<class Integral>
296 Integral atomic_fetch_add_explicit(volatile std::atomic<Integral>* obj, Integral arg,
297 std::memory_order order);
298
299 template<class T>
300 T* atomic_fetch_add(std::atomic<T*>* obj, std::ptrdiff_t arg);
301 template<class T>
302 T* atomic_fetch_add(volatile std::atomic<T*>* obj, std::ptrdiff_t arg);
303
304 template<class T>
305 T* atomic_fetch_add_explicit(std::atomic<T*>* obj, std::ptrdiff_t arg,
306 std::memory_order order);
307 template<class T>
308 T* atomic_fetch_add_explicit(volatile std::atomic<T*>* obj, std::ptrdiff_t arg,
309 std::memory_order order);
310
311 template<class Integral>
312 Integral atomic_fetch_sub(std::atomic<Integral>* obj, Integral arg);
313 template<class Integral>
314 Integral atomic_fetch_sub(volatile std::atomic<Integral>* obj, Integral arg);
315
316 template<class Integral>
317 Integral atomic_fetch_sub_explicit(std::atomic<Integral>* obj, Integral arg,
318 std::memory_order order);
319 template<class Integral>
320 Integral atomic_fetch_sub_explicit(volatile std::atomic<Integral>* obj, Integral arg,
321 std::memory_order order);
322
323 template<class T>
324 T* atomic_fetch_sub(std::atomic<T*>* obj, std::ptrdiff_t arg);
325 template<class T>
326 T* atomic_fetch_sub(volatile std::atomic<T*>* obj, std::ptrdiff_t arg);
327
328 template<class T>
329 T* atomic_fetch_sub_explicit(std::atomic<T*>* obj, std::ptrdiff_t arg,
330 std::memory_order order);
331 template<class T>
332 T* atomic_fetch_sub_explicit(volatile std::atomic<T*>* obj, std::ptrdiff_t arg,
333 std::memory_order order);
334
335 template<class Integral>
336 Integral atomic_fetch_and(std::atomic<Integral>* obj, Integral arg);
337 template<class Integral>
338 Integral atomic_fetch_and(volatile std::atomic<Integral>* obj, Integral arg);
339
340 template<class Integral>
341 Integral atomic_fetch_and_explicit(std::atomic<Integral>* obj,
342 Integral arg,
343 std::memory_order order);
344
345 template<class Integral>
346 Integral atomic_fetch_and_explicit(volatile std::atomic<Integral>* obj,
347 Integral arg,
348 std::memory_order order);
349 template<class Integral>
350 Integral atomic_fetch_or(std::atomic<Integral>* obj, Integral arg);
351 template<class Integral>
352 Integral atomic_fetch_or(volatile std::atomic<Integral>* obj, Integral arg);
353
354 template<class Integral>
355 Integral atomic_fetch_or_explicit(std::atomic<Integral>* obj,
356 Integral arg,
357 std::memory_order order);
358
359 template<class Integral>
360 Integral atomic_fetch_or_explicit(volatile std::atomic<Integral>* obj,
361 Integral arg,
362 std::memory_order order);
363
364 template<class Integral>
365 Integral atomic_fetch_xor(std::atomic<Integral>* obj, Integral arg);
366 template<class Integral>
367 Integral atomic_fetch_xor(volatile std::atomic<Integral>* obj, Integral arg);
368
369 template<class Integral>
370 Integral atomic_fetch_xor_explicit(std::atomic<Integral>* obj,
371 Integral arg,
372 std::memory_order order);
373
374 template<class Integral>
375 Integral atomic_fetch_xor_explicit(volatile std::atomic<Integral>* obj,
376 Integral arg,
377 std::memory_order order);
378
379 class atomic_flag {
380 public:
381 atomic_flag();
382 atomic_flag(const atomic_flag&) = delete;
383
384 atomic_flag& operator=(const atomic_flag&) = delete;
385 atomic_flag& operator=(const atomic_flag&) volatile = delete;
386
387 void clear(std::memory_order order = std::memory_order_seq_cst) volatile;
388 void clear(std::memory_order order = std::memory_order_seq_cst);
389
390 bool test_and_set(std::memory_order order = std::memory_order_seq_cst) volatile;
391 bool test_and_set(std::memory_order order = std::memory_order_seq_cst);
392 };
393
394 bool atomic_flag_test_and_set(volatile std::atomic_flag* p);
395 bool atomic_flag_test_and_set(std::atomic_flag* p);
396 bool atomic_flag_test_and_set_explicit(volatile std::atomic_flag* p,
397 std::memory_order order);
398 bool atomic_flag_test_and_set_explicit(std::atomic_flag* p,
399 std::memory_order order);
400
401 void atomic_flag_clear(volatile std::atomic_flag* p);
402 void atomic_flag_clear(std::atomic_flag* p);
403 void atomic_flag_clear_explicit(volatile std::atomic_flag* p,
404 std::memory_order order);
405 void atomic_flag_clear_explicit(std::atomic_flag* p,
406 std::memory_order order);
407
408 void atomic_signal_fence(std::memory_order order);
409 void atomic_thread_fence(std::memory_order order);
410 template<class T>
411 T kill_dependency(T y);
412
413 template<class T>
414 void atomic_init(std::atomic<T>* obj, T desired);
415
416 template<class T>
417 void atomic_init(volatile std::atomic<T>* obj, T desired);
418
419 #define ATOMIC_VAR_INIT(value) // impl-defined
420 #define ATOMIC_FLAG_INIT // impl-defined
421
422 #endif // CPPREFERENCE_STDVER>= 2011
423
424 } // namespace std
425
426 #endif // CPPREFERENCE_ATOMIC_H