32#ifndef _GLIBCXX_ATOMIC
33#define _GLIBCXX_ATOMIC 1
35#pragma GCC system_header
37#if __cplusplus < 201103L
41#define __glibcxx_want_atomic_is_always_lock_free
42#define __glibcxx_want_atomic_flag_test
43#define __glibcxx_want_atomic_float
44#define __glibcxx_want_atomic_ref
45#define __glibcxx_want_atomic_lock_free_type_aliases
46#define __glibcxx_want_atomic_value_initialization
47#define __glibcxx_want_atomic_wait
52namespace std _GLIBCXX_VISIBILITY(default)
54_GLIBCXX_BEGIN_NAMESPACE_VERSION
61 template<
typename _Tp>
69 using value_type = bool;
72 __atomic_base<bool> _M_base;
75 atomic()
noexcept =
default;
81 constexpr atomic(
bool __i) noexcept : _M_base(__i) { }
84 operator=(
bool __i)
noexcept
85 {
return _M_base.operator=(__i); }
88 operator=(
bool __i)
volatile noexcept
89 {
return _M_base.operator=(__i); }
91 operator bool()
const noexcept
92 {
return _M_base.load(); }
94 operator bool()
const volatile noexcept
95 {
return _M_base.load(); }
98 is_lock_free()
const noexcept {
return _M_base.is_lock_free(); }
101 is_lock_free()
const volatile noexcept {
return _M_base.is_lock_free(); }
103#ifdef __cpp_lib_atomic_is_always_lock_free
108 store(
bool __i,
memory_order __m = memory_order_seq_cst)
noexcept
109 { _M_base.store(__i, __m); }
112 store(
bool __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
113 { _M_base.store(__i, __m); }
116 load(
memory_order __m = memory_order_seq_cst)
const noexcept
117 {
return _M_base.load(__m); }
120 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
121 {
return _M_base.load(__m); }
124 exchange(
bool __i,
memory_order __m = memory_order_seq_cst)
noexcept
125 {
return _M_base.exchange(__i, __m); }
129 memory_order __m = memory_order_seq_cst)
volatile noexcept
130 {
return _M_base.exchange(__i, __m); }
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,
memory_order __m1,
140 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
143 compare_exchange_weak(
bool& __i1,
bool __i2,
145 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
148 compare_exchange_weak(
bool& __i1,
bool __i2,
149 memory_order __m = memory_order_seq_cst)
volatile noexcept
150 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
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,
memory_order __m1,
160 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
163 compare_exchange_strong(
bool& __i1,
bool __i2,
165 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
168 compare_exchange_strong(
bool& __i1,
bool __i2,
169 memory_order __m = memory_order_seq_cst)
volatile noexcept
170 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
172#if __cpp_lib_atomic_wait
174 wait(
bool __old,
memory_order __m = memory_order_seq_cst)
const noexcept
175 { _M_base.wait(__old, __m); }
180 notify_one()
noexcept
181 { _M_base.notify_one(); }
184 notify_all()
noexcept
185 { _M_base.notify_all(); }
190#if __cpp_lib_atomic_value_initialization
191# define _GLIBCXX20_INIT(I) = I
193# define _GLIBCXX20_INIT(I)
202 template<
typename _Tp>
205 using value_type = _Tp;
209 static constexpr int _S_min_alignment
210 = (
sizeof(_Tp) & (
sizeof(_Tp) - 1)) ||
sizeof(_Tp) > 16
213 static constexpr int _S_alignment
214 = _S_min_alignment >
alignof(_Tp) ? _S_min_alignment :
alignof(_Tp);
216 alignas(_S_alignment) _Tp _M_i _GLIBCXX20_INIT(_Tp());
218 static_assert(__is_trivially_copyable(_Tp),
219 "std::atomic requires a trivially copyable type");
221 static_assert(
sizeof(_Tp) > 0,
222 "Incomplete or zero-sized types are not supported");
224#if __cplusplus > 201703L
225 static_assert(is_copy_constructible_v<_Tp>);
226 static_assert(is_move_constructible_v<_Tp>);
227 static_assert(is_copy_assignable_v<_Tp>);
228 static_assert(is_move_assignable_v<_Tp>);
238 constexpr atomic(_Tp __i) noexcept : _M_i(__i)
240#if __cplusplus >= 201402L && __has_builtin(__builtin_clear_padding)
241 if _GLIBCXX17_CONSTEXPR (__atomic_impl::__maybe_has_padding<_Tp>())
246 operator _Tp()
const noexcept
249 operator _Tp()
const volatile noexcept
253 operator=(_Tp __i)
noexcept
254 { store(__i);
return __i; }
257 operator=(_Tp __i)
volatile noexcept
258 { store(__i);
return __i; }
261 is_lock_free()
const noexcept
264 return __atomic_is_lock_free(
sizeof(_M_i),
265 reinterpret_cast<void *
>(-_S_alignment));
269 is_lock_free()
const volatile noexcept
272 return __atomic_is_lock_free(
sizeof(_M_i),
273 reinterpret_cast<void *
>(-_S_alignment));
276#ifdef __cpp_lib_atomic_is_always_lock_free
277 static constexpr bool is_always_lock_free
278 = __atomic_always_lock_free(
sizeof(_M_i), 0);
282 store(_Tp __i,
memory_order __m = memory_order_seq_cst)
noexcept
285 __atomic_impl::__clear_padding(__i),
290 store(_Tp __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
293 __atomic_impl::__clear_padding(__i),
298 load(
memory_order __m = memory_order_seq_cst)
const noexcept
300 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
301 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
307 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
309 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
310 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
316 exchange(_Tp __i,
memory_order __m = memory_order_seq_cst)
noexcept
318 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
319 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
321 __atomic_impl::__clear_padding(__i),
328 memory_order __m = memory_order_seq_cst)
volatile noexcept
330 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
331 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
333 __atomic_impl::__clear_padding(__i),
339 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
342 return __atomic_impl::__compare_exchange(_M_i, __e, __i,
true,
347 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
350 return __atomic_impl::__compare_exchange(_M_i, __e, __i,
true,
355 compare_exchange_weak(_Tp& __e, _Tp __i,
357 {
return compare_exchange_weak(__e, __i, __m,
358 __cmpexch_failure_order(__m)); }
361 compare_exchange_weak(_Tp& __e, _Tp __i,
362 memory_order __m = memory_order_seq_cst)
volatile noexcept
363 {
return compare_exchange_weak(__e, __i, __m,
364 __cmpexch_failure_order(__m)); }
367 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
370 return __atomic_impl::__compare_exchange(_M_i, __e, __i,
false,
375 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
378 return __atomic_impl::__compare_exchange(_M_i, __e, __i,
false,
383 compare_exchange_strong(_Tp& __e, _Tp __i,
385 {
return compare_exchange_strong(__e, __i, __m,
386 __cmpexch_failure_order(__m)); }
389 compare_exchange_strong(_Tp& __e, _Tp __i,
390 memory_order __m = memory_order_seq_cst)
volatile noexcept
391 {
return compare_exchange_strong(__e, __i, __m,
392 __cmpexch_failure_order(__m)); }
394#if __cpp_lib_atomic_wait
396 wait(_Tp __old,
memory_order __m = memory_order_seq_cst)
const noexcept
398 std::__atomic_wait_address_v(&_M_i, __old,
399 [__m,
this] {
return this->load(__m); });
405 notify_one()
noexcept
406 { std::__atomic_notify_address(&_M_i,
false); }
409 notify_all()
noexcept
410 { std::__atomic_notify_address(&_M_i,
true); }
414#undef _GLIBCXX20_INIT
417 template<
typename _Tp>
420 using value_type = _Tp*;
421 using difference_type = ptrdiff_t;
423 typedef _Tp* __pointer_type;
424 typedef __atomic_base<_Tp*> __base_type;
427 atomic()
noexcept =
default;
433 constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
435 operator __pointer_type()
const noexcept
436 {
return __pointer_type(_M_b); }
438 operator __pointer_type()
const volatile noexcept
439 {
return __pointer_type(_M_b); }
442 operator=(__pointer_type __p)
noexcept
443 {
return _M_b.operator=(__p); }
446 operator=(__pointer_type __p)
volatile noexcept
447 {
return _M_b.operator=(__p); }
450 operator++(
int)
noexcept
452#if __cplusplus >= 201703L
459 operator++(
int)
volatile noexcept
461#if __cplusplus >= 201703L
468 operator--(
int)
noexcept
470#if __cplusplus >= 201703L
477 operator--(
int)
volatile noexcept
479#if __cplusplus >= 201703L
486 operator++()
noexcept
488#if __cplusplus >= 201703L
495 operator++()
volatile noexcept
497#if __cplusplus >= 201703L
504 operator--()
noexcept
506#if __cplusplus >= 201703L
513 operator--()
volatile noexcept
515#if __cplusplus >= 201703L
522 operator+=(ptrdiff_t __d)
noexcept
524#if __cplusplus >= 201703L
527 return _M_b.operator+=(__d);
531 operator+=(ptrdiff_t __d)
volatile noexcept
533#if __cplusplus >= 201703L
536 return _M_b.operator+=(__d);
540 operator-=(ptrdiff_t __d)
noexcept
542#if __cplusplus >= 201703L
545 return _M_b.operator-=(__d);
549 operator-=(ptrdiff_t __d)
volatile noexcept
551#if __cplusplus >= 201703L
554 return _M_b.operator-=(__d);
558 is_lock_free()
const noexcept
559 {
return _M_b.is_lock_free(); }
562 is_lock_free()
const volatile noexcept
563 {
return _M_b.is_lock_free(); }
565#ifdef __cpp_lib_atomic_is_always_lock_free
566 static constexpr bool is_always_lock_free
567 = ATOMIC_POINTER_LOCK_FREE == 2;
571 store(__pointer_type __p,
573 {
return _M_b.store(__p, __m); }
576 store(__pointer_type __p,
577 memory_order __m = memory_order_seq_cst)
volatile noexcept
578 {
return _M_b.store(__p, __m); }
581 load(
memory_order __m = memory_order_seq_cst)
const noexcept
582 {
return _M_b.load(__m); }
585 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
586 {
return _M_b.load(__m); }
589 exchange(__pointer_type __p,
591 {
return _M_b.exchange(__p, __m); }
594 exchange(__pointer_type __p,
595 memory_order __m = memory_order_seq_cst)
volatile noexcept
596 {
return _M_b.exchange(__p, __m); }
599 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
601 {
return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); }
604 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
607 {
return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); }
610 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
613 return compare_exchange_weak(__p1, __p2, __m,
614 __cmpexch_failure_order(__m));
618 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
619 memory_order __m = memory_order_seq_cst)
volatile noexcept
621 return compare_exchange_weak(__p1, __p2, __m,
622 __cmpexch_failure_order(__m));
626 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
628 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
631 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
634 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
637 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
640 return _M_b.compare_exchange_strong(__p1, __p2, __m,
641 __cmpexch_failure_order(__m));
645 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
646 memory_order __m = memory_order_seq_cst)
volatile noexcept
648 return _M_b.compare_exchange_strong(__p1, __p2, __m,
649 __cmpexch_failure_order(__m));
652#if __cpp_lib_atomic_wait
654 wait(__pointer_type __old,
memory_order __m = memory_order_seq_cst)
const noexcept
655 { _M_b.wait(__old, __m); }
660 notify_one()
noexcept
661 { _M_b.notify_one(); }
664 notify_all()
noexcept
665 { _M_b.notify_all(); }
669 fetch_add(ptrdiff_t __d,
672#if __cplusplus >= 201703L
675 return _M_b.fetch_add(__d, __m);
679 fetch_add(ptrdiff_t __d,
680 memory_order __m = memory_order_seq_cst)
volatile noexcept
682#if __cplusplus >= 201703L
685 return _M_b.fetch_add(__d, __m);
689 fetch_sub(ptrdiff_t __d,
692#if __cplusplus >= 201703L
695 return _M_b.fetch_sub(__d, __m);
699 fetch_sub(ptrdiff_t __d,
700 memory_order __m = memory_order_seq_cst)
volatile noexcept
702#if __cplusplus >= 201703L
705 return _M_b.fetch_sub(__d, __m);
712 struct atomic<char> : __atomic_base<char>
714 typedef char __integral_type;
715 typedef __atomic_base<char> __base_type;
717 atomic()
noexcept =
default;
723 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
725 using __base_type::operator __integral_type;
726 using __base_type::operator=;
728#ifdef __cpp_lib_atomic_is_always_lock_free
729 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
735 struct atomic<signed char> : __atomic_base<signed char>
737 typedef signed char __integral_type;
738 typedef __atomic_base<signed char> __base_type;
740 atomic()
noexcept=
default;
746 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
748 using __base_type::operator __integral_type;
749 using __base_type::operator=;
751#ifdef __cpp_lib_atomic_is_always_lock_free
752 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
758 struct atomic<unsigned char> : __atomic_base<unsigned char>
760 typedef unsigned char __integral_type;
761 typedef __atomic_base<unsigned char> __base_type;
763 atomic()
noexcept=
default;
769 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
771 using __base_type::operator __integral_type;
772 using __base_type::operator=;
774#ifdef __cpp_lib_atomic_is_always_lock_free
775 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
781 struct atomic<short> : __atomic_base<short>
783 typedef short __integral_type;
784 typedef __atomic_base<short> __base_type;
786 atomic()
noexcept =
default;
792 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
794 using __base_type::operator __integral_type;
795 using __base_type::operator=;
797#ifdef __cpp_lib_atomic_is_always_lock_free
798 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
804 struct atomic<unsigned short> : __atomic_base<unsigned short>
806 typedef unsigned short __integral_type;
807 typedef __atomic_base<unsigned short> __base_type;
809 atomic()
noexcept =
default;
815 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
817 using __base_type::operator __integral_type;
818 using __base_type::operator=;
820#ifdef __cpp_lib_atomic_is_always_lock_free
821 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
829 typedef int __integral_type;
830 typedef __atomic_base<int> __base_type;
832 atomic()
noexcept =
default;
838 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
840 using __base_type::operator __integral_type;
841 using __base_type::operator=;
843#ifdef __cpp_lib_atomic_is_always_lock_free
844 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
850 struct atomic<unsigned int> : __atomic_base<unsigned int>
852 typedef unsigned int __integral_type;
853 typedef __atomic_base<unsigned int> __base_type;
855 atomic()
noexcept =
default;
861 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
863 using __base_type::operator __integral_type;
864 using __base_type::operator=;
866#ifdef __cpp_lib_atomic_is_always_lock_free
867 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
873 struct atomic<long> : __atomic_base<long>
875 typedef long __integral_type;
876 typedef __atomic_base<long> __base_type;
878 atomic()
noexcept =
default;
884 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
886 using __base_type::operator __integral_type;
887 using __base_type::operator=;
889#ifdef __cpp_lib_atomic_is_always_lock_free
890 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
896 struct atomic<unsigned long> : __atomic_base<unsigned long>
898 typedef unsigned long __integral_type;
899 typedef __atomic_base<unsigned long> __base_type;
901 atomic()
noexcept =
default;
907 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
909 using __base_type::operator __integral_type;
910 using __base_type::operator=;
912#ifdef __cpp_lib_atomic_is_always_lock_free
913 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
919 struct atomic<long long> : __atomic_base<long long>
921 typedef long long __integral_type;
922 typedef __atomic_base<long long> __base_type;
924 atomic()
noexcept =
default;
930 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
932 using __base_type::operator __integral_type;
933 using __base_type::operator=;
935#ifdef __cpp_lib_atomic_is_always_lock_free
936 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
942 struct atomic<unsigned long long> : __atomic_base<unsigned long long>
944 typedef unsigned long long __integral_type;
945 typedef __atomic_base<unsigned long long> __base_type;
947 atomic()
noexcept =
default;
953 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
955 using __base_type::operator __integral_type;
956 using __base_type::operator=;
958#ifdef __cpp_lib_atomic_is_always_lock_free
959 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
965 struct atomic<wchar_t> : __atomic_base<wchar_t>
967 typedef wchar_t __integral_type;
968 typedef __atomic_base<wchar_t> __base_type;
970 atomic()
noexcept =
default;
976 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
978 using __base_type::operator __integral_type;
979 using __base_type::operator=;
981#ifdef __cpp_lib_atomic_is_always_lock_free
982 static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
986#ifdef _GLIBCXX_USE_CHAR8_T
989 struct atomic<char8_t> : __atomic_base<char8_t>
991 typedef char8_t __integral_type;
992 typedef __atomic_base<char8_t> __base_type;
994 atomic() noexcept = default;
995 ~
atomic() noexcept = default;
1000 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
1002 using __base_type::operator __integral_type;
1003 using __base_type::operator=;
1005#ifdef __cpp_lib_atomic_is_always_lock_free
1006 static constexpr bool is_always_lock_free
1007 = ATOMIC_CHAR8_T_LOCK_FREE == 2;
1014 struct atomic<char16_t> : __atomic_base<char16_t>
1016 typedef char16_t __integral_type;
1017 typedef __atomic_base<char16_t> __base_type;
1019 atomic()
noexcept =
default;
1025 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1027 using __base_type::operator __integral_type;
1028 using __base_type::operator=;
1030#ifdef __cpp_lib_atomic_is_always_lock_free
1031 static constexpr bool is_always_lock_free
1032 = ATOMIC_CHAR16_T_LOCK_FREE == 2;
1038 struct atomic<char32_t> : __atomic_base<char32_t>
1040 typedef char32_t __integral_type;
1041 typedef __atomic_base<char32_t> __base_type;
1043 atomic()
noexcept =
default;
1049 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1051 using __base_type::operator __integral_type;
1052 using __base_type::operator=;
1054#ifdef __cpp_lib_atomic_is_always_lock_free
1055 static constexpr bool is_always_lock_free
1056 = ATOMIC_CHAR32_T_LOCK_FREE == 2;
1100#ifdef _GLIBCXX_USE_CHAR8_T
1111#ifdef _GLIBCXX_USE_C99_STDINT
1210 atomic_flag_test_and_set_explicit(
atomic_flag* __a,
1212 {
return __a->test_and_set(__m); }
1215 atomic_flag_test_and_set_explicit(
volatile atomic_flag* __a,
1217 {
return __a->test_and_set(__m); }
1219#if __cpp_lib_atomic_flag_test
1221 atomic_flag_test(
const atomic_flag* __a)
noexcept
1222 {
return __a->test(); }
1225 atomic_flag_test(
const volatile atomic_flag* __a)
noexcept
1226 {
return __a->test(); }
1229 atomic_flag_test_explicit(
const atomic_flag* __a,
1231 {
return __a->test(__m); }
1234 atomic_flag_test_explicit(
const volatile atomic_flag* __a,
1236 {
return __a->test(__m); }
1240 atomic_flag_clear_explicit(atomic_flag* __a,
memory_order __m)
noexcept
1241 { __a->clear(__m); }
1244 atomic_flag_clear_explicit(
volatile atomic_flag* __a,
1246 { __a->clear(__m); }
1249 atomic_flag_test_and_set(atomic_flag* __a)
noexcept
1250 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1253 atomic_flag_test_and_set(
volatile atomic_flag* __a)
noexcept
1254 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1257 atomic_flag_clear(atomic_flag* __a)
noexcept
1258 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1261 atomic_flag_clear(
volatile atomic_flag* __a)
noexcept
1262 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1264#if __cpp_lib_atomic_wait
1266 atomic_flag_wait(atomic_flag* __a,
bool __old)
noexcept
1267 { __a->wait(__old); }
1270 atomic_flag_wait_explicit(atomic_flag* __a,
bool __old,
1272 { __a->wait(__old, __m); }
1275 atomic_flag_notify_one(atomic_flag* __a)
noexcept
1276 { __a->notify_one(); }
1279 atomic_flag_notify_all(atomic_flag* __a)
noexcept
1280 { __a->notify_all(); }
1286 template<
typename _Tp>
1287 using __atomic_val_t = __type_identity_t<_Tp>;
1288 template<
typename _Tp>
1289 using __atomic_diff_t =
typename atomic<_Tp>::difference_type;
1294 template<
typename _ITp>
1296 atomic_is_lock_free(
const atomic<_ITp>* __a)
noexcept
1297 {
return __a->is_lock_free(); }
1299 template<
typename _ITp>
1301 atomic_is_lock_free(
const volatile atomic<_ITp>* __a)
noexcept
1302 {
return __a->is_lock_free(); }
1304 template<
typename _ITp>
1306 atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1307 { __a->store(__i, memory_order_relaxed); }
1309 template<
typename _ITp>
1311 atomic_init(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1312 { __a->store(__i, memory_order_relaxed); }
1314 template<
typename _ITp>
1316 atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1318 { __a->store(__i, __m); }
1320 template<
typename _ITp>
1322 atomic_store_explicit(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1324 { __a->store(__i, __m); }
1326 template<
typename _ITp>
1328 atomic_load_explicit(
const atomic<_ITp>* __a,
memory_order __m)
noexcept
1329 {
return __a->load(__m); }
1331 template<
typename _ITp>
1333 atomic_load_explicit(
const volatile atomic<_ITp>* __a,
1335 {
return __a->load(__m); }
1337 template<
typename _ITp>
1339 atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1341 {
return __a->exchange(__i, __m); }
1343 template<
typename _ITp>
1345 atomic_exchange_explicit(
volatile atomic<_ITp>* __a,
1346 __atomic_val_t<_ITp> __i,
1348 {
return __a->exchange(__i, __m); }
1350 template<
typename _ITp>
1352 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1353 __atomic_val_t<_ITp>* __i1,
1354 __atomic_val_t<_ITp> __i2,
1357 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1359 template<
typename _ITp>
1361 atomic_compare_exchange_weak_explicit(
volatile atomic<_ITp>* __a,
1362 __atomic_val_t<_ITp>* __i1,
1363 __atomic_val_t<_ITp> __i2,
1366 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1368 template<
typename _ITp>
1370 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1371 __atomic_val_t<_ITp>* __i1,
1372 __atomic_val_t<_ITp> __i2,
1375 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1377 template<
typename _ITp>
1379 atomic_compare_exchange_strong_explicit(
volatile atomic<_ITp>* __a,
1380 __atomic_val_t<_ITp>* __i1,
1381 __atomic_val_t<_ITp> __i2,
1384 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1387 template<
typename _ITp>
1389 atomic_store(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_store(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1395 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1397 template<
typename _ITp>
1399 atomic_load(
const atomic<_ITp>* __a)
noexcept
1400 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1402 template<
typename _ITp>
1404 atomic_load(
const volatile atomic<_ITp>* __a)
noexcept
1405 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1407 template<
typename _ITp>
1409 atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1410 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1412 template<
typename _ITp>
1414 atomic_exchange(
volatile atomic<_ITp>* __a,
1415 __atomic_val_t<_ITp> __i)
noexcept
1416 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1418 template<
typename _ITp>
1420 atomic_compare_exchange_weak(atomic<_ITp>* __a,
1421 __atomic_val_t<_ITp>* __i1,
1422 __atomic_val_t<_ITp> __i2)
noexcept
1424 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1425 memory_order_seq_cst,
1426 memory_order_seq_cst);
1429 template<
typename _ITp>
1431 atomic_compare_exchange_weak(
volatile atomic<_ITp>* __a,
1432 __atomic_val_t<_ITp>* __i1,
1433 __atomic_val_t<_ITp> __i2)
noexcept
1435 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1436 memory_order_seq_cst,
1437 memory_order_seq_cst);
1440 template<
typename _ITp>
1442 atomic_compare_exchange_strong(atomic<_ITp>* __a,
1443 __atomic_val_t<_ITp>* __i1,
1444 __atomic_val_t<_ITp> __i2)
noexcept
1446 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1447 memory_order_seq_cst,
1448 memory_order_seq_cst);
1451 template<
typename _ITp>
1453 atomic_compare_exchange_strong(
volatile atomic<_ITp>* __a,
1454 __atomic_val_t<_ITp>* __i1,
1455 __atomic_val_t<_ITp> __i2)
noexcept
1457 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1458 memory_order_seq_cst,
1459 memory_order_seq_cst);
1463#if __cpp_lib_atomic_wait
1464 template<
typename _Tp>
1466 atomic_wait(
const atomic<_Tp>* __a,
1467 typename std::atomic<_Tp>::value_type __old)
noexcept
1468 { __a->wait(__old); }
1470 template<
typename _Tp>
1472 atomic_wait_explicit(
const atomic<_Tp>* __a,
1473 typename std::atomic<_Tp>::value_type __old,
1475 { __a->wait(__old, __m); }
1477 template<
typename _Tp>
1479 atomic_notify_one(atomic<_Tp>* __a)
noexcept
1480 { __a->notify_one(); }
1482 template<
typename _Tp>
1484 atomic_notify_all(atomic<_Tp>* __a)
noexcept
1485 { __a->notify_all(); }
1492 template<
typename _ITp>
1494 atomic_fetch_add_explicit(atomic<_ITp>* __a,
1495 __atomic_diff_t<_ITp> __i,
1497 {
return __a->fetch_add(__i, __m); }
1499 template<
typename _ITp>
1501 atomic_fetch_add_explicit(
volatile atomic<_ITp>* __a,
1502 __atomic_diff_t<_ITp> __i,
1504 {
return __a->fetch_add(__i, __m); }
1506 template<
typename _ITp>
1508 atomic_fetch_sub_explicit(atomic<_ITp>* __a,
1509 __atomic_diff_t<_ITp> __i,
1511 {
return __a->fetch_sub(__i, __m); }
1513 template<
typename _ITp>
1515 atomic_fetch_sub_explicit(
volatile atomic<_ITp>* __a,
1516 __atomic_diff_t<_ITp> __i,
1518 {
return __a->fetch_sub(__i, __m); }
1520 template<
typename _ITp>
1522 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
1523 __atomic_val_t<_ITp> __i,
1525 {
return __a->fetch_and(__i, __m); }
1527 template<
typename _ITp>
1529 atomic_fetch_and_explicit(
volatile __atomic_base<_ITp>* __a,
1530 __atomic_val_t<_ITp> __i,
1532 {
return __a->fetch_and(__i, __m); }
1534 template<
typename _ITp>
1536 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
1537 __atomic_val_t<_ITp> __i,
1539 {
return __a->fetch_or(__i, __m); }
1541 template<
typename _ITp>
1543 atomic_fetch_or_explicit(
volatile __atomic_base<_ITp>* __a,
1544 __atomic_val_t<_ITp> __i,
1546 {
return __a->fetch_or(__i, __m); }
1548 template<
typename _ITp>
1550 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
1551 __atomic_val_t<_ITp> __i,
1553 {
return __a->fetch_xor(__i, __m); }
1555 template<
typename _ITp>
1557 atomic_fetch_xor_explicit(
volatile __atomic_base<_ITp>* __a,
1558 __atomic_val_t<_ITp> __i,
1560 {
return __a->fetch_xor(__i, __m); }
1562 template<
typename _ITp>
1564 atomic_fetch_add(atomic<_ITp>* __a,
1565 __atomic_diff_t<_ITp> __i)
noexcept
1566 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1568 template<
typename _ITp>
1570 atomic_fetch_add(
volatile atomic<_ITp>* __a,
1571 __atomic_diff_t<_ITp> __i)
noexcept
1572 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1574 template<
typename _ITp>
1576 atomic_fetch_sub(atomic<_ITp>* __a,
1577 __atomic_diff_t<_ITp> __i)
noexcept
1578 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1580 template<
typename _ITp>
1582 atomic_fetch_sub(
volatile atomic<_ITp>* __a,
1583 __atomic_diff_t<_ITp> __i)
noexcept
1584 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1586 template<
typename _ITp>
1588 atomic_fetch_and(__atomic_base<_ITp>* __a,
1589 __atomic_val_t<_ITp> __i)
noexcept
1590 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1592 template<
typename _ITp>
1594 atomic_fetch_and(
volatile __atomic_base<_ITp>* __a,
1595 __atomic_val_t<_ITp> __i)
noexcept
1596 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1598 template<
typename _ITp>
1600 atomic_fetch_or(__atomic_base<_ITp>* __a,
1601 __atomic_val_t<_ITp> __i)
noexcept
1602 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1604 template<
typename _ITp>
1606 atomic_fetch_or(
volatile __atomic_base<_ITp>* __a,
1607 __atomic_val_t<_ITp> __i)
noexcept
1608 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1610 template<
typename _ITp>
1612 atomic_fetch_xor(__atomic_base<_ITp>* __a,
1613 __atomic_val_t<_ITp> __i)
noexcept
1614 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1616 template<
typename _ITp>
1618 atomic_fetch_xor(
volatile __atomic_base<_ITp>* __a,
1619 __atomic_val_t<_ITp> __i)
noexcept
1620 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1622#ifdef __cpp_lib_atomic_float
1624 struct atomic<float> : __atomic_float<float>
1626 atomic() noexcept = default;
1629 atomic(
float __fp) noexcept : __atomic_float<
float>(__fp)
1632 atomic& operator=(
const atomic&)
volatile =
delete;
1633 atomic& operator=(
const atomic&) =
delete;
1635 using __atomic_float<
float>::operator=;
1639 struct atomic<double> : __atomic_float<double>
1641 atomic() noexcept = default;
1644 atomic(
double __fp) noexcept : __atomic_float<
double>(__fp)
1647 atomic& operator=(
const atomic&)
volatile =
delete;
1648 atomic& operator=(
const atomic&) =
delete;
1650 using __atomic_float<
double>::operator=;
1654 struct atomic<long double> : __atomic_float<long double>
1656 atomic() noexcept = default;
1659 atomic(
long double __fp) noexcept : __atomic_float<
long double>(__fp)
1662 atomic& operator=(
const atomic&)
volatile =
delete;
1663 atomic& operator=(
const atomic&) =
delete;
1665 using __atomic_float<
long double>::operator=;
1668#ifdef __STDCPP_FLOAT16_T__
1670 struct atomic<_Float16> : __atomic_float<_Float16>
1672 atomic() noexcept = default;
1675 atomic(_Float16 __fp) noexcept : __atomic_float<_Float16>(__fp)
1678 atomic& operator=(
const atomic&)
volatile =
delete;
1679 atomic& operator=(
const atomic&) =
delete;
1681 using __atomic_float<_Float16>::operator=;
1685#ifdef __STDCPP_FLOAT32_T__
1687 struct atomic<_Float32> : __atomic_float<_Float32>
1689 atomic() noexcept = default;
1692 atomic(_Float32 __fp) noexcept : __atomic_float<_Float32>(__fp)
1695 atomic& operator=(
const atomic&)
volatile =
delete;
1696 atomic& operator=(
const atomic&) =
delete;
1698 using __atomic_float<_Float32>::operator=;
1702#ifdef __STDCPP_FLOAT64_T__
1704 struct atomic<_Float64> : __atomic_float<_Float64>
1706 atomic() noexcept = default;
1709 atomic(_Float64 __fp) noexcept : __atomic_float<_Float64>(__fp)
1712 atomic& operator=(
const atomic&)
volatile =
delete;
1713 atomic& operator=(
const atomic&) =
delete;
1715 using __atomic_float<_Float64>::operator=;
1719#ifdef __STDCPP_FLOAT128_T__
1721 struct atomic<_Float128> : __atomic_float<_Float128>
1723 atomic() noexcept = default;
1726 atomic(_Float128 __fp) noexcept : __atomic_float<_Float128>(__fp)
1729 atomic& operator=(
const atomic&)
volatile =
delete;
1730 atomic& operator=(
const atomic&) =
delete;
1732 using __atomic_float<_Float128>::operator=;
1736#ifdef __STDCPP_BFLOAT16_T__
1738 struct atomic<
__gnu_cxx::__bfloat16_t> : __atomic_float<__gnu_cxx::__bfloat16_t>
1740 atomic() noexcept = default;
1743 atomic(
__gnu_cxx::__bfloat16_t __fp) noexcept : __atomic_float<
__gnu_cxx::__bfloat16_t>(__fp)
1746 atomic& operator=(
const atomic&)
volatile =
delete;
1747 atomic& operator=(
const atomic&) =
delete;
1749 using __atomic_float<__gnu_cxx::__bfloat16_t>::operator=;
1754#ifdef __cpp_lib_atomic_ref
1756 template<
typename _Tp>
1757 struct atomic_ref : __atomic_ref<_Tp>
1760 atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t)
1763 atomic_ref& operator=(
const atomic_ref&) =
delete;
1765 atomic_ref(
const atomic_ref&) =
default;
1767 using __atomic_ref<_Tp>::operator=;
1771#ifdef __cpp_lib_atomic_lock_free_type_aliases
1772# ifdef _GLIBCXX_HAVE_PLATFORM_WAIT
1773 using atomic_signed_lock_free
1774 = atomic<make_signed_t<__detail::__platform_wait_t>>;
1775 using atomic_unsigned_lock_free
1776 = atomic<make_unsigned_t<__detail::__platform_wait_t>>;
1777# elif ATOMIC_INT_LOCK_FREE || !(ATOMIC_LONG_LOCK_FREE || ATOMIC_CHAR_LOCK_FREE)
1778 using atomic_signed_lock_free = atomic<signed int>;
1779 using atomic_unsigned_lock_free = atomic<unsigned int>;
1780# elif ATOMIC_LONG_LOCK_FREE
1781 using atomic_signed_lock_free = atomic<signed long>;
1782 using atomic_unsigned_lock_free = atomic<unsigned long>;
1783# elif ATOMIC_CHAR_LOCK_FREE
1784 using atomic_signed_lock_free = atomic<signed char>;
1785 using atomic_unsigned_lock_free = atomic<unsigned char>;
1787# error "libstdc++ bug: no lock-free atomics but they were emitted in <version>"
1793_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
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
memory_order
Enumeration for memory_order.
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.
GNU extensions for public use.
Generic atomic type, primary class template.