32#ifndef _GLIBCXX_ATOMIC
33#define _GLIBCXX_ATOMIC 1
35#pragma GCC system_header
37#if __cplusplus < 201103L
43namespace std _GLIBCXX_VISIBILITY(default)
45_GLIBCXX_BEGIN_NAMESPACE_VERSION
52#if __cplusplus >= 201703L
53# define __cpp_lib_atomic_is_always_lock_free 201603
56 template<
typename _Tp>
64 using value_type = bool;
70 atomic()
noexcept =
default;
76 constexpr atomic(
bool __i) noexcept : _M_base(__i) { }
79 operator=(
bool __i)
noexcept
80 {
return _M_base.operator=(__i); }
83 operator=(
bool __i)
volatile noexcept
84 {
return _M_base.operator=(__i); }
86 operator bool()
const noexcept
87 {
return _M_base.load(); }
89 operator bool()
const volatile noexcept
90 {
return _M_base.load(); }
93 is_lock_free()
const noexcept {
return _M_base.is_lock_free(); }
96 is_lock_free()
const volatile noexcept {
return _M_base.is_lock_free(); }
98#if __cplusplus >= 201703L
103 store(
bool __i,
memory_order __m = memory_order_seq_cst)
noexcept
104 { _M_base.store(__i, __m); }
107 store(
bool __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
108 { _M_base.store(__i, __m); }
111 load(
memory_order __m = memory_order_seq_cst)
const noexcept
112 {
return _M_base.load(__m); }
115 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
116 {
return _M_base.load(__m); }
119 exchange(
bool __i,
memory_order __m = memory_order_seq_cst)
noexcept
120 {
return _M_base.exchange(__i, __m); }
124 memory_order __m = memory_order_seq_cst)
volatile noexcept
125 {
return _M_base.exchange(__i, __m); }
128 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
130 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
133 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
135 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
138 compare_exchange_weak(
bool& __i1,
bool __i2,
140 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
143 compare_exchange_weak(
bool& __i1,
bool __i2,
144 memory_order __m = memory_order_seq_cst)
volatile noexcept
145 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
148 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
150 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
153 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
155 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
158 compare_exchange_strong(
bool& __i1,
bool __i2,
160 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
163 compare_exchange_strong(
bool& __i1,
bool __i2,
164 memory_order __m = memory_order_seq_cst)
volatile noexcept
165 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
167#if __cpp_lib_atomic_wait
169 wait(
bool __old,
memory_order __m = memory_order_seq_cst)
const noexcept
170 { _M_base.wait(__old, __m); }
175 notify_one()
noexcept
176 { _M_base.notify_one(); }
179 notify_all()
noexcept
180 { _M_base.notify_all(); }
184#if __cplusplus <= 201703L
185# define _GLIBCXX20_INIT(I)
187# define _GLIBCXX20_INIT(I) = I
195 template<
typename _Tp>
198 using value_type = _Tp;
202 static constexpr int _S_min_alignment
203 = (
sizeof(_Tp) & (
sizeof(_Tp) - 1)) ||
sizeof(_Tp) > 16
206 static constexpr int _S_alignment
207 = _S_min_alignment >
alignof(_Tp) ? _S_min_alignment :
alignof(_Tp);
209 alignas(_S_alignment) _Tp _M_i _GLIBCXX20_INIT(_Tp());
211 static_assert(__is_trivially_copyable(_Tp),
212 "std::atomic requires a trivially copyable type");
214 static_assert(
sizeof(_Tp) > 0,
215 "Incomplete or zero-sized types are not supported");
217#if __cplusplus > 201703L
218 static_assert(is_copy_constructible_v<_Tp>);
219 static_assert(is_move_constructible_v<_Tp>);
220 static_assert(is_copy_assignable_v<_Tp>);
221 static_assert(is_move_assignable_v<_Tp>);
231 constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
233 operator _Tp()
const noexcept
236 operator _Tp()
const volatile noexcept
240 operator=(_Tp __i)
noexcept
241 { store(__i);
return __i; }
244 operator=(_Tp __i)
volatile noexcept
245 { store(__i);
return __i; }
248 is_lock_free()
const noexcept
251 return __atomic_is_lock_free(
sizeof(_M_i),
252 reinterpret_cast<void *
>(-_S_alignment));
256 is_lock_free()
const volatile noexcept
259 return __atomic_is_lock_free(
sizeof(_M_i),
260 reinterpret_cast<void *
>(-_S_alignment));
263#if __cplusplus >= 201703L
264 static constexpr bool is_always_lock_free
265 = __atomic_always_lock_free(
sizeof(_M_i), 0);
269 store(_Tp __i,
memory_order __m = memory_order_seq_cst)
noexcept
275 store(_Tp __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
281 load(
memory_order __m = memory_order_seq_cst)
const noexcept
283 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
284 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
290 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
292 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
293 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
299 exchange(_Tp __i,
memory_order __m = memory_order_seq_cst)
noexcept
301 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
302 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
310 memory_order __m = memory_order_seq_cst)
volatile noexcept
312 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
313 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
320 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
323 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
328 true,
int(__s),
int(__f));
332 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
335 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
340 true,
int(__s),
int(__f));
344 compare_exchange_weak(_Tp& __e, _Tp __i,
346 {
return compare_exchange_weak(__e, __i, __m,
347 __cmpexch_failure_order(__m)); }
350 compare_exchange_weak(_Tp& __e, _Tp __i,
351 memory_order __m = memory_order_seq_cst)
volatile noexcept
352 {
return compare_exchange_weak(__e, __i, __m,
353 __cmpexch_failure_order(__m)); }
356 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
359 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
364 false,
int(__s),
int(__f));
368 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
371 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
376 false,
int(__s),
int(__f));
380 compare_exchange_strong(_Tp& __e, _Tp __i,
382 {
return compare_exchange_strong(__e, __i, __m,
383 __cmpexch_failure_order(__m)); }
386 compare_exchange_strong(_Tp& __e, _Tp __i,
387 memory_order __m = memory_order_seq_cst)
volatile noexcept
388 {
return compare_exchange_strong(__e, __i, __m,
389 __cmpexch_failure_order(__m)); }
391#if __cpp_lib_atomic_wait
393 wait(_Tp __old,
memory_order __m = memory_order_seq_cst)
const noexcept
395 std::__atomic_wait_address_v(&_M_i, __old,
396 [__m,
this] {
return this->load(__m); });
402 notify_one()
noexcept
403 { std::__atomic_notify_address(&_M_i,
false); }
406 notify_all()
noexcept
407 { std::__atomic_notify_address(&_M_i,
true); }
411#undef _GLIBCXX20_INIT
414 template<
typename _Tp>
417 using value_type = _Tp*;
418 using difference_type = ptrdiff_t;
420 typedef _Tp* __pointer_type;
424 atomic()
noexcept =
default;
430 constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
432 operator __pointer_type()
const noexcept
433 {
return __pointer_type(_M_b); }
435 operator __pointer_type()
const volatile noexcept
436 {
return __pointer_type(_M_b); }
439 operator=(__pointer_type __p)
noexcept
440 {
return _M_b.operator=(__p); }
443 operator=(__pointer_type __p)
volatile noexcept
444 {
return _M_b.operator=(__p); }
447 operator++(
int)
noexcept
449#if __cplusplus >= 201703L
456 operator++(
int)
volatile noexcept
458#if __cplusplus >= 201703L
465 operator--(
int)
noexcept
467#if __cplusplus >= 201703L
474 operator--(
int)
volatile noexcept
476#if __cplusplus >= 201703L
483 operator++()
noexcept
485#if __cplusplus >= 201703L
492 operator++()
volatile noexcept
494#if __cplusplus >= 201703L
501 operator--()
noexcept
503#if __cplusplus >= 201703L
510 operator--()
volatile noexcept
512#if __cplusplus >= 201703L
519 operator+=(ptrdiff_t __d)
noexcept
521#if __cplusplus >= 201703L
524 return _M_b.operator+=(__d);
528 operator+=(ptrdiff_t __d)
volatile noexcept
530#if __cplusplus >= 201703L
533 return _M_b.operator+=(__d);
537 operator-=(ptrdiff_t __d)
noexcept
539#if __cplusplus >= 201703L
542 return _M_b.operator-=(__d);
546 operator-=(ptrdiff_t __d)
volatile noexcept
548#if __cplusplus >= 201703L
551 return _M_b.operator-=(__d);
555 is_lock_free()
const noexcept
556 {
return _M_b.is_lock_free(); }
559 is_lock_free()
const volatile noexcept
560 {
return _M_b.is_lock_free(); }
562#if __cplusplus >= 201703L
563 static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
567 store(__pointer_type __p,
569 {
return _M_b.store(__p, __m); }
572 store(__pointer_type __p,
573 memory_order __m = memory_order_seq_cst)
volatile noexcept
574 {
return _M_b.store(__p, __m); }
577 load(
memory_order __m = memory_order_seq_cst)
const noexcept
578 {
return _M_b.load(__m); }
581 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
582 {
return _M_b.load(__m); }
587 {
return _M_b.exchange(__p, __m); }
591 memory_order __m = memory_order_seq_cst)
volatile noexcept
592 {
return _M_b.exchange(__p, __m); }
595 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
597 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
600 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
603 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
606 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
609 return compare_exchange_weak(__p1, __p2, __m,
610 __cmpexch_failure_order(__m));
614 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
615 memory_order __m = memory_order_seq_cst)
volatile noexcept
617 return compare_exchange_weak(__p1, __p2, __m,
618 __cmpexch_failure_order(__m));
622 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
624 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
627 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
630 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
633 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
636 return _M_b.compare_exchange_strong(__p1, __p2, __m,
637 __cmpexch_failure_order(__m));
641 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
642 memory_order __m = memory_order_seq_cst)
volatile noexcept
644 return _M_b.compare_exchange_strong(__p1, __p2, __m,
645 __cmpexch_failure_order(__m));
648#if __cpp_lib_atomic_wait
650 wait(__pointer_type __old,
memory_order __m = memory_order_seq_cst)
const noexcept
651 { _M_b.wait(__old, __m); }
656 notify_one()
noexcept
657 { _M_b.notify_one(); }
660 notify_all()
noexcept
661 { _M_b.notify_all(); }
664 fetch_add(ptrdiff_t __d,
667#if __cplusplus >= 201703L
670 return _M_b.fetch_add(__d, __m);
674 fetch_add(ptrdiff_t __d,
675 memory_order __m = memory_order_seq_cst)
volatile noexcept
677#if __cplusplus >= 201703L
680 return _M_b.fetch_add(__d, __m);
684 fetch_sub(ptrdiff_t __d,
687#if __cplusplus >= 201703L
690 return _M_b.fetch_sub(__d, __m);
694 fetch_sub(ptrdiff_t __d,
695 memory_order __m = memory_order_seq_cst)
volatile noexcept
697#if __cplusplus >= 201703L
700 return _M_b.fetch_sub(__d, __m);
709 typedef char __integral_type;
712 atomic()
noexcept =
default;
720 using __base_type::operator __integral_type;
721 using __base_type::operator=;
723#if __cplusplus >= 201703L
724 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
732 typedef signed char __integral_type;
735 atomic()
noexcept=
default;
743 using __base_type::operator __integral_type;
744 using __base_type::operator=;
746#if __cplusplus >= 201703L
747 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
755 typedef unsigned char __integral_type;
758 atomic()
noexcept=
default;
766 using __base_type::operator __integral_type;
767 using __base_type::operator=;
769#if __cplusplus >= 201703L
770 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
778 typedef short __integral_type;
781 atomic()
noexcept =
default;
789 using __base_type::operator __integral_type;
790 using __base_type::operator=;
792#if __cplusplus >= 201703L
793 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
801 typedef unsigned short __integral_type;
804 atomic()
noexcept =
default;
812 using __base_type::operator __integral_type;
813 using __base_type::operator=;
815#if __cplusplus >= 201703L
816 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
824 typedef int __integral_type;
827 atomic()
noexcept =
default;
835 using __base_type::operator __integral_type;
836 using __base_type::operator=;
838#if __cplusplus >= 201703L
839 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
847 typedef unsigned int __integral_type;
850 atomic()
noexcept =
default;
858 using __base_type::operator __integral_type;
859 using __base_type::operator=;
861#if __cplusplus >= 201703L
862 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
870 typedef long __integral_type;
873 atomic()
noexcept =
default;
881 using __base_type::operator __integral_type;
882 using __base_type::operator=;
884#if __cplusplus >= 201703L
885 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
893 typedef unsigned long __integral_type;
896 atomic()
noexcept =
default;
904 using __base_type::operator __integral_type;
905 using __base_type::operator=;
907#if __cplusplus >= 201703L
908 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
916 typedef long long __integral_type;
919 atomic()
noexcept =
default;
927 using __base_type::operator __integral_type;
928 using __base_type::operator=;
930#if __cplusplus >= 201703L
931 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
939 typedef unsigned long long __integral_type;
942 atomic()
noexcept =
default;
950 using __base_type::operator __integral_type;
951 using __base_type::operator=;
953#if __cplusplus >= 201703L
954 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
962 typedef wchar_t __integral_type;
965 atomic()
noexcept =
default;
973 using __base_type::operator __integral_type;
974 using __base_type::operator=;
976#if __cplusplus >= 201703L
977 static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
981#ifdef _GLIBCXX_USE_CHAR8_T
986 typedef char8_t __integral_type;
989 atomic() noexcept = default;
990 ~
atomic() noexcept = default;
995 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
997 using __base_type::operator __integral_type;
998 using __base_type::operator=;
1000#if __cplusplus > 201402L
1001 static constexpr bool is_always_lock_free = ATOMIC_CHAR8_T_LOCK_FREE == 2;
1010 typedef char16_t __integral_type;
1013 atomic()
noexcept =
default;
1021 using __base_type::operator __integral_type;
1022 using __base_type::operator=;
1024#if __cplusplus >= 201703L
1025 static constexpr bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2;
1033 typedef char32_t __integral_type;
1036 atomic()
noexcept =
default;
1044 using __base_type::operator __integral_type;
1045 using __base_type::operator=;
1047#if __cplusplus >= 201703L
1048 static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2;
1092#ifdef _GLIBCXX_USE_CHAR8_T
1103#ifdef _GLIBCXX_USE_C99_STDINT_TR1
1195#ifdef _GLIBCXX_USE_C99_STDINT_TR1
1205 atomic_flag_test_and_set_explicit(
atomic_flag* __a,
1207 {
return __a->test_and_set(__m); }
1210 atomic_flag_test_and_set_explicit(
volatile atomic_flag* __a,
1212 {
return __a->test_and_set(__m); }
1214#if __cpp_lib_atomic_flag_test
1216 atomic_flag_test(
const atomic_flag* __a)
noexcept
1217 {
return __a->test(); }
1220 atomic_flag_test(
const volatile atomic_flag* __a)
noexcept
1221 {
return __a->test(); }
1224 atomic_flag_test_explicit(
const atomic_flag* __a,
1226 {
return __a->test(__m); }
1229 atomic_flag_test_explicit(
const volatile atomic_flag* __a,
1231 {
return __a->test(__m); }
1235 atomic_flag_clear_explicit(atomic_flag* __a,
memory_order __m)
noexcept
1236 { __a->clear(__m); }
1239 atomic_flag_clear_explicit(
volatile atomic_flag* __a,
1241 { __a->clear(__m); }
1244 atomic_flag_test_and_set(atomic_flag* __a)
noexcept
1245 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1248 atomic_flag_test_and_set(
volatile atomic_flag* __a)
noexcept
1249 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1252 atomic_flag_clear(atomic_flag* __a)
noexcept
1253 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1256 atomic_flag_clear(
volatile atomic_flag* __a)
noexcept
1257 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1259#if __cpp_lib_atomic_wait
1261 atomic_flag_wait(atomic_flag* __a,
bool __old)
noexcept
1262 { __a->wait(__old); }
1265 atomic_flag_wait_explicit(atomic_flag* __a,
bool __old,
1267 { __a->wait(__old, __m); }
1270 atomic_flag_notify_one(atomic_flag* __a)
noexcept
1271 { __a->notify_one(); }
1274 atomic_flag_notify_all(atomic_flag* __a)
noexcept
1275 { __a->notify_all(); }
1281 template<
typename _Tp>
1282 using __atomic_val_t = __type_identity_t<_Tp>;
1283 template<
typename _Tp>
1284 using __atomic_diff_t =
typename atomic<_Tp>::difference_type;
1289 template<
typename _ITp>
1291 atomic_is_lock_free(
const atomic<_ITp>* __a)
noexcept
1292 {
return __a->is_lock_free(); }
1294 template<
typename _ITp>
1296 atomic_is_lock_free(
const volatile atomic<_ITp>* __a)
noexcept
1297 {
return __a->is_lock_free(); }
1299 template<
typename _ITp>
1301 atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1302 { __a->store(__i, memory_order_relaxed); }
1304 template<
typename _ITp>
1306 atomic_init(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1307 { __a->store(__i, memory_order_relaxed); }
1309 template<
typename _ITp>
1311 atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1313 { __a->store(__i, __m); }
1315 template<
typename _ITp>
1317 atomic_store_explicit(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1319 { __a->store(__i, __m); }
1321 template<
typename _ITp>
1323 atomic_load_explicit(
const atomic<_ITp>* __a,
memory_order __m)
noexcept
1324 {
return __a->load(__m); }
1326 template<
typename _ITp>
1328 atomic_load_explicit(
const volatile atomic<_ITp>* __a,
1330 {
return __a->load(__m); }
1332 template<
typename _ITp>
1334 atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1336 {
return __a->exchange(__i, __m); }
1338 template<
typename _ITp>
1340 atomic_exchange_explicit(
volatile atomic<_ITp>* __a,
1341 __atomic_val_t<_ITp> __i,
1343 {
return __a->exchange(__i, __m); }
1345 template<
typename _ITp>
1347 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1348 __atomic_val_t<_ITp>* __i1,
1349 __atomic_val_t<_ITp> __i2,
1352 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1354 template<
typename _ITp>
1356 atomic_compare_exchange_weak_explicit(
volatile atomic<_ITp>* __a,
1357 __atomic_val_t<_ITp>* __i1,
1358 __atomic_val_t<_ITp> __i2,
1361 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1363 template<
typename _ITp>
1365 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1366 __atomic_val_t<_ITp>* __i1,
1367 __atomic_val_t<_ITp> __i2,
1370 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1372 template<
typename _ITp>
1374 atomic_compare_exchange_strong_explicit(
volatile atomic<_ITp>* __a,
1375 __atomic_val_t<_ITp>* __i1,
1376 __atomic_val_t<_ITp> __i2,
1379 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1382 template<
typename _ITp>
1384 atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1385 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1387 template<
typename _ITp>
1389 atomic_store(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1390 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1392 template<
typename _ITp>
1394 atomic_load(
const atomic<_ITp>* __a)
noexcept
1395 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1397 template<
typename _ITp>
1399 atomic_load(
const volatile atomic<_ITp>* __a)
noexcept
1400 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1402 template<
typename _ITp>
1404 atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1405 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1407 template<
typename _ITp>
1409 atomic_exchange(
volatile atomic<_ITp>* __a,
1410 __atomic_val_t<_ITp> __i)
noexcept
1411 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1413 template<
typename _ITp>
1415 atomic_compare_exchange_weak(atomic<_ITp>* __a,
1416 __atomic_val_t<_ITp>* __i1,
1417 __atomic_val_t<_ITp> __i2)
noexcept
1419 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1420 memory_order_seq_cst,
1421 memory_order_seq_cst);
1424 template<
typename _ITp>
1426 atomic_compare_exchange_weak(
volatile atomic<_ITp>* __a,
1427 __atomic_val_t<_ITp>* __i1,
1428 __atomic_val_t<_ITp> __i2)
noexcept
1430 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1431 memory_order_seq_cst,
1432 memory_order_seq_cst);
1435 template<
typename _ITp>
1437 atomic_compare_exchange_strong(atomic<_ITp>* __a,
1438 __atomic_val_t<_ITp>* __i1,
1439 __atomic_val_t<_ITp> __i2)
noexcept
1441 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1442 memory_order_seq_cst,
1443 memory_order_seq_cst);
1446 template<
typename _ITp>
1448 atomic_compare_exchange_strong(
volatile atomic<_ITp>* __a,
1449 __atomic_val_t<_ITp>* __i1,
1450 __atomic_val_t<_ITp> __i2)
noexcept
1452 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1453 memory_order_seq_cst,
1454 memory_order_seq_cst);
1458#if __cpp_lib_atomic_wait
1459 template<
typename _Tp>
1461 atomic_wait(
const atomic<_Tp>* __a,
1462 typename std::atomic<_Tp>::value_type __old)
noexcept
1463 { __a->wait(__old); }
1465 template<
typename _Tp>
1467 atomic_wait_explicit(
const atomic<_Tp>* __a,
1468 typename std::atomic<_Tp>::value_type __old,
1470 { __a->wait(__old, __m); }
1472 template<
typename _Tp>
1474 atomic_notify_one(atomic<_Tp>* __a)
noexcept
1475 { __a->notify_one(); }
1477 template<
typename _Tp>
1479 atomic_notify_all(atomic<_Tp>* __a)
noexcept
1480 { __a->notify_all(); }
1487 template<
typename _ITp>
1489 atomic_fetch_add_explicit(atomic<_ITp>* __a,
1490 __atomic_diff_t<_ITp> __i,
1492 {
return __a->fetch_add(__i, __m); }
1494 template<
typename _ITp>
1496 atomic_fetch_add_explicit(
volatile atomic<_ITp>* __a,
1497 __atomic_diff_t<_ITp> __i,
1499 {
return __a->fetch_add(__i, __m); }
1501 template<
typename _ITp>
1503 atomic_fetch_sub_explicit(atomic<_ITp>* __a,
1504 __atomic_diff_t<_ITp> __i,
1506 {
return __a->fetch_sub(__i, __m); }
1508 template<
typename _ITp>
1510 atomic_fetch_sub_explicit(
volatile atomic<_ITp>* __a,
1511 __atomic_diff_t<_ITp> __i,
1513 {
return __a->fetch_sub(__i, __m); }
1515 template<
typename _ITp>
1517 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
1518 __atomic_val_t<_ITp> __i,
1520 {
return __a->fetch_and(__i, __m); }
1522 template<
typename _ITp>
1524 atomic_fetch_and_explicit(
volatile __atomic_base<_ITp>* __a,
1525 __atomic_val_t<_ITp> __i,
1527 {
return __a->fetch_and(__i, __m); }
1529 template<
typename _ITp>
1531 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
1532 __atomic_val_t<_ITp> __i,
1534 {
return __a->fetch_or(__i, __m); }
1536 template<
typename _ITp>
1538 atomic_fetch_or_explicit(
volatile __atomic_base<_ITp>* __a,
1539 __atomic_val_t<_ITp> __i,
1541 {
return __a->fetch_or(__i, __m); }
1543 template<
typename _ITp>
1545 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
1546 __atomic_val_t<_ITp> __i,
1548 {
return __a->fetch_xor(__i, __m); }
1550 template<
typename _ITp>
1552 atomic_fetch_xor_explicit(
volatile __atomic_base<_ITp>* __a,
1553 __atomic_val_t<_ITp> __i,
1555 {
return __a->fetch_xor(__i, __m); }
1557 template<
typename _ITp>
1559 atomic_fetch_add(atomic<_ITp>* __a,
1560 __atomic_diff_t<_ITp> __i)
noexcept
1561 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1563 template<
typename _ITp>
1565 atomic_fetch_add(
volatile atomic<_ITp>* __a,
1566 __atomic_diff_t<_ITp> __i)
noexcept
1567 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1569 template<
typename _ITp>
1571 atomic_fetch_sub(atomic<_ITp>* __a,
1572 __atomic_diff_t<_ITp> __i)
noexcept
1573 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1575 template<
typename _ITp>
1577 atomic_fetch_sub(
volatile atomic<_ITp>* __a,
1578 __atomic_diff_t<_ITp> __i)
noexcept
1579 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1581 template<
typename _ITp>
1583 atomic_fetch_and(__atomic_base<_ITp>* __a,
1584 __atomic_val_t<_ITp> __i)
noexcept
1585 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1587 template<
typename _ITp>
1589 atomic_fetch_and(
volatile __atomic_base<_ITp>* __a,
1590 __atomic_val_t<_ITp> __i)
noexcept
1591 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1593 template<
typename _ITp>
1595 atomic_fetch_or(__atomic_base<_ITp>* __a,
1596 __atomic_val_t<_ITp> __i)
noexcept
1597 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1599 template<
typename _ITp>
1601 atomic_fetch_or(
volatile __atomic_base<_ITp>* __a,
1602 __atomic_val_t<_ITp> __i)
noexcept
1603 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1605 template<
typename _ITp>
1607 atomic_fetch_xor(__atomic_base<_ITp>* __a,
1608 __atomic_val_t<_ITp> __i)
noexcept
1609 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1611 template<
typename _ITp>
1613 atomic_fetch_xor(
volatile __atomic_base<_ITp>* __a,
1614 __atomic_val_t<_ITp> __i)
noexcept
1615 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1617#if __cplusplus > 201703L
1618#define __cpp_lib_atomic_float 201711L
1620 struct atomic<float> : __atomic_float<float>
1622 atomic() noexcept = default;
1625 atomic(
float __fp) noexcept : __atomic_float<
float>(__fp)
1628 atomic& operator=(
const atomic&)
volatile =
delete;
1629 atomic& operator=(
const atomic&) =
delete;
1631 using __atomic_float<
float>::operator=;
1635 struct atomic<double> : __atomic_float<double>
1637 atomic() noexcept = default;
1640 atomic(
double __fp) noexcept : __atomic_float<
double>(__fp)
1643 atomic& operator=(
const atomic&)
volatile =
delete;
1644 atomic& operator=(
const atomic&) =
delete;
1646 using __atomic_float<
double>::operator=;
1650 struct atomic<long double> : __atomic_float<long double>
1652 atomic() noexcept = default;
1655 atomic(
long double __fp) noexcept : __atomic_float<
long double>(__fp)
1658 atomic& operator=(
const atomic&)
volatile =
delete;
1659 atomic& operator=(
const atomic&) =
delete;
1661 using __atomic_float<
long double>::operator=;
1664#define __cpp_lib_atomic_ref 201806L
1667 template<
typename _Tp>
1668 struct atomic_ref : __atomic_ref<_Tp>
1671 atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t)
1674 atomic_ref& operator=(
const atomic_ref&) =
delete;
1676 atomic_ref(
const atomic_ref&) =
default;
1678 using __atomic_ref<_Tp>::operator=;
1685_GLIBCXX_END_NAMESPACE_VERSION
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
atomic< unsigned long > atomic_ulong
atomic_ulong
atomic< intmax_t > atomic_intmax_t
atomic_intmax_t
atomic< uintptr_t > atomic_uintptr_t
atomic_uintptr_t
atomic< signed char > atomic_schar
atomic_schar
atomic< int_least8_t > atomic_int_least8_t
atomic_int_least8_t
atomic< unsigned long long > atomic_ullong
atomic_ullong
atomic< uint_fast8_t > atomic_uint_fast8_t
atomic_uint_fast8_t
atomic< intptr_t > atomic_intptr_t
atomic_intptr_t
atomic< int16_t > atomic_int16_t
atomic_int16_t
atomic< size_t > atomic_size_t
atomic_size_t
atomic< long > atomic_long
atomic_long
atomic< uint_least8_t > atomic_uint_least8_t
atomic_uint_least8_t
atomic< short > atomic_short
atomic_short
atomic< uint_least16_t > atomic_uint_least16_t
atomic_uint_least16_t
atomic< uint16_t > atomic_uint16_t
atomic_uint16_t
atomic< uint64_t > atomic_uint64_t
atomic_uint64_t
atomic< int_least32_t > atomic_int_least32_t
atomic_int_least32_t
atomic< uint8_t > atomic_uint8_t
atomic_uint8_t
#define ATOMIC_BOOL_LOCK_FREE
atomic< wchar_t > atomic_wchar_t
atomic_wchar_t
atomic< unsigned int > atomic_uint
atomic_uint
atomic< uint_least32_t > atomic_uint_least32_t
atomic_uint_least32_t
atomic< uint_fast64_t > atomic_uint_fast64_t
atomic_uint_fast64_t
atomic< int_fast32_t > atomic_int_fast32_t
atomic_int_fast32_t
atomic< char > atomic_char
atomic_char
atomic< int > atomic_int
atomic_int
atomic< uint_least64_t > atomic_uint_least64_t
atomic_uint_least64_t
atomic< int64_t > atomic_int64_t
atomic_int64_t
atomic< uintmax_t > atomic_uintmax_t
atomic_uintmax_t
atomic< int_fast16_t > atomic_int_fast16_t
atomic_int_fast16_t
atomic< int32_t > atomic_int32_t
atomic_int32_t
memory_order
Enumeration for memory_order.
atomic< uint_fast16_t > atomic_uint_fast16_t
atomic_uint_fast16_t
atomic< int8_t > atomic_int8_t
atomic_int8_t
atomic< long long > atomic_llong
atomic_llong
atomic< char16_t > atomic_char16_t
atomic_char16_t
atomic< int_fast64_t > atomic_int_fast64_t
atomic_int_fast64_t
atomic< ptrdiff_t > atomic_ptrdiff_t
atomic_ptrdiff_t
atomic< char32_t > atomic_char32_t
atomic_char32_t
atomic< int_least16_t > atomic_int_least16_t
atomic_int_least16_t
atomic< unsigned char > atomic_uchar
atomic_uchar
atomic< int_fast8_t > atomic_int_fast8_t
atomic_int_fast8_t
atomic< unsigned short > atomic_ushort
atomic_ushort
atomic< int_least64_t > atomic_int_least64_t
atomic_int_least64_t
atomic< bool > atomic_bool
atomic_bool
atomic< uint_fast32_t > atomic_uint_fast32_t
atomic_uint_fast32_t
atomic< uint32_t > atomic_uint32_t
atomic_uint32_t
ISO C++ entities toplevel namespace is std.
constexpr _Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.
Generic atomic type, primary class template.
Base class for atomic integrals.