Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/atomic
$ cat -n /usr/include/c++/13/atomic 1 // -*- C++ -*- header. 2 3 // Copyright (C) 2008-2023 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file include/atomic 26 * This is a Standard C++ Library header. 27 */ 28 29 // Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl. 30 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html 31 32 #ifndef _GLIBCXX_ATOMIC 33 #define _GLIBCXX_ATOMIC 1 34 35 #pragma GCC system_header 36 37 #if __cplusplus < 201103L 38 # include <bits/c++0x_warning.h> 39 #else 40 41 #include <bits/atomic_base.h> 42 43 namespace std _GLIBCXX_VISIBILITY(default) 44 { 45 _GLIBCXX_BEGIN_NAMESPACE_VERSION 46 47 /** 48 * @addtogroup atomics 49 * @{ 50 */ 51 52 #if __cplusplus >= 201703L 53 # define __cpp_lib_atomic_is_always_lock_free 201603L 54 #endif 55 56 template<typename _Tp> 57 struct atomic; 58 59 /// atomic<bool> 60 // NB: No operators or fetch-operations for this type. 61 template<> 62 struct atomic<bool> 63 { 64 using value_type = bool; 65 66 private: 67 __atomic_base<bool> _M_base; 68 69 public: 70 atomic() noexcept = default; 71 ~atomic() noexcept = default; 72 atomic(const atomic&) = delete; 73 atomic& operator=(const atomic&) = delete; 74 atomic& operator=(const atomic&) volatile = delete; 75 76 constexpr atomic(bool __i) noexcept : _M_base(__i) { } 77 78 bool 79 operator=(bool __i) noexcept 80 { return _M_base.operator=(__i); } 81 82 bool 83 operator=(bool __i) volatile noexcept 84 { return _M_base.operator=(__i); } 85 86 operator bool() const noexcept 87 { return _M_base.load(); } 88 89 operator bool() const volatile noexcept 90 { return _M_base.load(); } 91 92 bool 93 is_lock_free() const noexcept { return _M_base.is_lock_free(); } 94 95 bool 96 is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } 97 98 #if __cplusplus >= 201703L 99 static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE == 2; 100 #endif 101 102 void 103 store(bool __i, memory_order __m = memory_order_seq_cst) noexcept 104 { _M_base.store(__i, __m); } 105 106 void 107 store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept 108 { _M_base.store(__i, __m); } 109 110 bool 111 load(memory_order __m = memory_order_seq_cst) const noexcept 112 { return _M_base.load(__m); } 113 114 bool 115 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 116 { return _M_base.load(__m); } 117 118 bool 119 exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept 120 { return _M_base.exchange(__i, __m); } 121 122 bool 123 exchange(bool __i, 124 memory_order __m = memory_order_seq_cst) volatile noexcept 125 { return _M_base.exchange(__i, __m); } 126 127 bool 128 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, 129 memory_order __m2) noexcept 130 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } 131 132 bool 133 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, 134 memory_order __m2) volatile noexcept 135 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } 136 137 bool 138 compare_exchange_weak(bool& __i1, bool __i2, 139 memory_order __m = memory_order_seq_cst) noexcept 140 { return _M_base.compare_exchange_weak(__i1, __i2, __m); } 141 142 bool 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); } 146 147 bool 148 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, 149 memory_order __m2) noexcept 150 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } 151 152 bool 153 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, 154 memory_order __m2) volatile noexcept 155 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } 156 157 bool 158 compare_exchange_strong(bool& __i1, bool __i2, 159 memory_order __m = memory_order_seq_cst) noexcept 160 { return _M_base.compare_exchange_strong(__i1, __i2, __m); } 161 162 bool 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); } 166 167 #if __cpp_lib_atomic_wait 168 void 169 wait(bool __old, memory_order __m = memory_order_seq_cst) const noexcept 170 { _M_base.wait(__old, __m); } 171 172 // TODO add const volatile overload 173 174 void 175 notify_one() noexcept 176 { _M_base.notify_one(); } 177 178 void 179 notify_all() noexcept 180 { _M_base.notify_all(); } 181 #endif // __cpp_lib_atomic_wait 182 }; 183 184 /// @cond undocumented 185 #if __cpp_lib_atomic_value_initialization 186 # define _GLIBCXX20_INIT(I) = I 187 #else 188 # define _GLIBCXX20_INIT(I) 189 #endif 190 /// @endcond 191 192 /** 193 * @brief Generic atomic type, primary class template. 194 * 195 * @tparam _Tp Type to be made atomic, must be trivially copyable. 196 */ 197 template<typename _Tp> 198 struct atomic 199 { 200 using value_type = _Tp; 201 202 private: 203 // Align 1/2/4/8/16-byte types to at least their size. 204 static constexpr int _S_min_alignment 205 = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16 206 ? 0 : sizeof(_Tp); 207 208 static constexpr int _S_alignment 209 = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp); 210 211 alignas(_S_alignment) _Tp _M_i _GLIBCXX20_INIT(_Tp()); 212 213 static_assert(__is_trivially_copyable(_Tp), 214 "std::atomic requires a trivially copyable type"); 215 216 static_assert(sizeof(_Tp) > 0, 217 "Incomplete or zero-sized types are not supported"); 218 219 #if __cplusplus > 201703L 220 static_assert(is_copy_constructible_v<_Tp>); 221 static_assert(is_move_constructible_v<_Tp>); 222 static_assert(is_copy_assignable_v<_Tp>); 223 static_assert(is_move_assignable_v<_Tp>); 224 #endif 225 226 public: 227 atomic() = default; 228 ~atomic() noexcept = default; 229 atomic(const atomic&) = delete; 230 atomic& operator=(const atomic&) = delete; 231 atomic& operator=(const atomic&) volatile = delete; 232 233 constexpr atomic(_Tp __i) noexcept : _M_i(__i) 234 { 235 #if __cplusplus >= 201402L && __has_builtin(__builtin_clear_padding) 236 if _GLIBCXX17_CONSTEXPR (__atomic_impl::__maybe_has_padding<_Tp>()) 237 __builtin_clear_padding(std::__addressof(_M_i)); 238 #endif 239 } 240 241 operator _Tp() const noexcept 242 { return load(); } 243 244 operator _Tp() const volatile noexcept 245 { return load(); } 246 247 _Tp 248 operator=(_Tp __i) noexcept 249 { store(__i); return __i; } 250 251 _Tp 252 operator=(_Tp __i) volatile noexcept 253 { store(__i); return __i; } 254 255 bool 256 is_lock_free() const noexcept 257 { 258 // Produce a fake, minimally aligned pointer. 259 return __atomic_is_lock_free(sizeof(_M_i), 260 reinterpret_cast<void *>(-_S_alignment)); 261 } 262 263 bool 264 is_lock_free() const volatile noexcept 265 { 266 // Produce a fake, minimally aligned pointer. 267 return __atomic_is_lock_free(sizeof(_M_i), 268 reinterpret_cast<void *>(-_S_alignment)); 269 } 270 271 #if __cplusplus >= 201703L 272 static constexpr bool is_always_lock_free 273 = __atomic_always_lock_free(sizeof(_M_i), 0); 274 #endif 275 276 void 277 store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept 278 { 279 __atomic_store(std::__addressof(_M_i), 280 __atomic_impl::__clear_padding(__i), 281 int(__m)); 282 } 283 284 void 285 store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept 286 { 287 __atomic_store(std::__addressof(_M_i), 288 __atomic_impl::__clear_padding(__i), 289 int(__m)); 290 } 291 292 _Tp 293 load(memory_order __m = memory_order_seq_cst) const noexcept 294 { 295 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 296 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); 297 __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); 298 return *__ptr; 299 } 300 301 _Tp 302 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 303 { 304 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 305 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); 306 __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); 307 return *__ptr; 308 } 309 310 _Tp 311 exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept 312 { 313 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 314 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); 315 __atomic_exchange(std::__addressof(_M_i), 316 __atomic_impl::__clear_padding(__i), 317 __ptr, int(__m)); 318 return *__ptr; 319 } 320 321 _Tp 322 exchange(_Tp __i, 323 memory_order __m = memory_order_seq_cst) volatile noexcept 324 { 325 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 326 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); 327 __atomic_exchange(std::__addressof(_M_i), 328 __atomic_impl::__clear_padding(__i), 329 __ptr, int(__m)); 330 return *__ptr; 331 } 332 333 bool 334 compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 335 memory_order __f) noexcept 336 { 337 return __atomic_impl::__compare_exchange(_M_i, __e, __i, true, 338 __s, __f); 339 } 340 341 bool 342 compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 343 memory_order __f) volatile noexcept 344 { 345 return __atomic_impl::__compare_exchange(_M_i, __e, __i, true, 346 __s, __f); 347 } 348 349 bool 350 compare_exchange_weak(_Tp& __e, _Tp __i, 351 memory_order __m = memory_order_seq_cst) noexcept 352 { return compare_exchange_weak(__e, __i, __m, 353 __cmpexch_failure_order(__m)); } 354 355 bool 356 compare_exchange_weak(_Tp& __e, _Tp __i, 357 memory_order __m = memory_order_seq_cst) volatile noexcept 358 { return compare_exchange_weak(__e, __i, __m, 359 __cmpexch_failure_order(__m)); } 360 361 bool 362 compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 363 memory_order __f) noexcept 364 { 365 return __atomic_impl::__compare_exchange(_M_i, __e, __i, false, 366 __s, __f); 367 } 368 369 bool 370 compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 371 memory_order __f) volatile noexcept 372 { 373 return __atomic_impl::__compare_exchange(_M_i, __e, __i, false, 374 __s, __f); 375 } 376 377 bool 378 compare_exchange_strong(_Tp& __e, _Tp __i, 379 memory_order __m = memory_order_seq_cst) noexcept 380 { return compare_exchange_strong(__e, __i, __m, 381 __cmpexch_failure_order(__m)); } 382 383 bool 384 compare_exchange_strong(_Tp& __e, _Tp __i, 385 memory_order __m = memory_order_seq_cst) volatile noexcept 386 { return compare_exchange_strong(__e, __i, __m, 387 __cmpexch_failure_order(__m)); } 388 389 #if __cpp_lib_atomic_wait 390 void 391 wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept 392 { 393 std::__atomic_wait_address_v(&_M_i, __old, 394 [__m, this] { return this->load(__m); }); 395 } 396 397 // TODO add const volatile overload 398 399 void 400 notify_one() noexcept 401 { std::__atomic_notify_address(&_M_i, false); } 402 403 void 404 notify_all() noexcept 405 { std::__atomic_notify_address(&_M_i, true); } 406 #endif // __cpp_lib_atomic_wait 407 408 }; 409 #undef _GLIBCXX20_INIT 410 411 /// Partial specialization for pointer types. 412 template<typename _Tp> 413 struct atomic<_Tp*> 414 { 415 using value_type = _Tp*; 416 using difference_type = ptrdiff_t; 417 418 typedef _Tp* __pointer_type; 419 typedef __atomic_base<_Tp*> __base_type; 420 __base_type _M_b; 421 422 atomic() noexcept = default; 423 ~atomic() noexcept = default; 424 atomic(const atomic&) = delete; 425 atomic& operator=(const atomic&) = delete; 426 atomic& operator=(const atomic&) volatile = delete; 427 428 constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { } 429 430 operator __pointer_type() const noexcept 431 { return __pointer_type(_M_b); } 432 433 operator __pointer_type() const volatile noexcept 434 { return __pointer_type(_M_b); } 435 436 __pointer_type 437 operator=(__pointer_type __p) noexcept 438 { return _M_b.operator=(__p); } 439 440 __pointer_type 441 operator=(__pointer_type __p) volatile noexcept 442 { return _M_b.operator=(__p); } 443 444 __pointer_type 445 operator++(int) noexcept 446 { 447 #if __cplusplus >= 201703L 448 static_assert( is_object<_Tp>::value, "pointer to object type" ); 449 #endif 450 return _M_b++; 451 } 452 453 __pointer_type 454 operator++(int) volatile noexcept 455 { 456 #if __cplusplus >= 201703L 457 static_assert( is_object<_Tp>::value, "pointer to object type" ); 458 #endif 459 return _M_b++; 460 } 461 462 __pointer_type 463 operator--(int) noexcept 464 { 465 #if __cplusplus >= 201703L 466 static_assert( is_object<_Tp>::value, "pointer to object type" ); 467 #endif 468 return _M_b--; 469 } 470 471 __pointer_type 472 operator--(int) volatile noexcept 473 { 474 #if __cplusplus >= 201703L 475 static_assert( is_object<_Tp>::value, "pointer to object type" ); 476 #endif 477 return _M_b--; 478 } 479 480 __pointer_type 481 operator++() noexcept 482 { 483 #if __cplusplus >= 201703L 484 static_assert( is_object<_Tp>::value, "pointer to object type" ); 485 #endif 486 return ++_M_b; 487 } 488 489 __pointer_type 490 operator++() volatile noexcept 491 { 492 #if __cplusplus >= 201703L 493 static_assert( is_object<_Tp>::value, "pointer to object type" ); 494 #endif 495 return ++_M_b; 496 } 497 498 __pointer_type 499 operator--() noexcept 500 { 501 #if __cplusplus >= 201703L 502 static_assert( is_object<_Tp>::value, "pointer to object type" ); 503 #endif 504 return --_M_b; 505 } 506 507 __pointer_type 508 operator--() volatile noexcept 509 { 510 #if __cplusplus >= 201703L 511 static_assert( is_object<_Tp>::value, "pointer to object type" ); 512 #endif 513 return --_M_b; 514 } 515 516 __pointer_type 517 operator+=(ptrdiff_t __d) noexcept 518 { 519 #if __cplusplus >= 201703L 520 static_assert( is_object<_Tp>::value, "pointer to object type" ); 521 #endif 522 return _M_b.operator+=(__d); 523 } 524 525 __pointer_type 526 operator+=(ptrdiff_t __d) volatile noexcept 527 { 528 #if __cplusplus >= 201703L 529 static_assert( is_object<_Tp>::value, "pointer to object type" ); 530 #endif 531 return _M_b.operator+=(__d); 532 } 533 534 __pointer_type 535 operator-=(ptrdiff_t __d) noexcept 536 { 537 #if __cplusplus >= 201703L 538 static_assert( is_object<_Tp>::value, "pointer to object type" ); 539 #endif 540 return _M_b.operator-=(__d); 541 } 542 543 __pointer_type 544 operator-=(ptrdiff_t __d) volatile noexcept 545 { 546 #if __cplusplus >= 201703L 547 static_assert( is_object<_Tp>::value, "pointer to object type" ); 548 #endif 549 return _M_b.operator-=(__d); 550 } 551 552 bool 553 is_lock_free() const noexcept 554 { return _M_b.is_lock_free(); } 555 556 bool 557 is_lock_free() const volatile noexcept 558 { return _M_b.is_lock_free(); } 559 560 #if __cplusplus >= 201703L 561 static constexpr bool is_always_lock_free 562 = ATOMIC_POINTER_LOCK_FREE == 2; 563 #endif 564 565 void 566 store(__pointer_type __p, 567 memory_order __m = memory_order_seq_cst) noexcept 568 { return _M_b.store(__p, __m); } 569 570 void 571 store(__pointer_type __p, 572 memory_order __m = memory_order_seq_cst) volatile noexcept 573 { return _M_b.store(__p, __m); } 574 575 __pointer_type 576 load(memory_order __m = memory_order_seq_cst) const noexcept 577 { return _M_b.load(__m); } 578 579 __pointer_type 580 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 581 { return _M_b.load(__m); } 582 583 __pointer_type 584 exchange(__pointer_type __p, 585 memory_order __m = memory_order_seq_cst) noexcept 586 { return _M_b.exchange(__p, __m); } 587 588 __pointer_type 589 exchange(__pointer_type __p, 590 memory_order __m = memory_order_seq_cst) volatile noexcept 591 { return _M_b.exchange(__p, __m); } 592 593 bool 594 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, 595 memory_order __m1, memory_order __m2) noexcept 596 { return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); } 597 598 bool 599 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, 600 memory_order __m1, 601 memory_order __m2) volatile noexcept 602 { return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); } 603 604 bool 605 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, 606 memory_order __m = memory_order_seq_cst) noexcept 607 { 608 return compare_exchange_weak(__p1, __p2, __m, 609 __cmpexch_failure_order(__m)); 610 } 611 612 bool 613 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, 614 memory_order __m = memory_order_seq_cst) volatile noexcept 615 { 616 return compare_exchange_weak(__p1, __p2, __m, 617 __cmpexch_failure_order(__m)); 618 } 619 620 bool 621 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 622 memory_order __m1, memory_order __m2) noexcept 623 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } 624 625 bool 626 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 627 memory_order __m1, 628 memory_order __m2) volatile noexcept 629 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } 630 631 bool 632 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 633 memory_order __m = memory_order_seq_cst) noexcept 634 { 635 return _M_b.compare_exchange_strong(__p1, __p2, __m, 636 __cmpexch_failure_order(__m)); 637 } 638 639 bool 640 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 641 memory_order __m = memory_order_seq_cst) volatile noexcept 642 { 643 return _M_b.compare_exchange_strong(__p1, __p2, __m, 644 __cmpexch_failure_order(__m)); 645 } 646 647 #if __cpp_lib_atomic_wait 648 void 649 wait(__pointer_type __old, memory_order __m = memory_order_seq_cst) const noexcept 650 { _M_b.wait(__old, __m); } 651 652 // TODO add const volatile overload 653 654 void 655 notify_one() noexcept 656 { _M_b.notify_one(); } 657 658 void 659 notify_all() noexcept 660 { _M_b.notify_all(); } 661 #endif // __cpp_lib_atomic_wait 662 663 __pointer_type 664 fetch_add(ptrdiff_t __d, 665 memory_order __m = memory_order_seq_cst) noexcept 666 { 667 #if __cplusplus >= 201703L 668 static_assert( is_object<_Tp>::value, "pointer to object type" ); 669 #endif 670 return _M_b.fetch_add(__d, __m); 671 } 672 673 __pointer_type 674 fetch_add(ptrdiff_t __d, 675 memory_order __m = memory_order_seq_cst) volatile noexcept 676 { 677 #if __cplusplus >= 201703L 678 static_assert( is_object<_Tp>::value, "pointer to object type" ); 679 #endif 680 return _M_b.fetch_add(__d, __m); 681 } 682 683 __pointer_type 684 fetch_sub(ptrdiff_t __d, 685 memory_order __m = memory_order_seq_cst) noexcept 686 { 687 #if __cplusplus >= 201703L 688 static_assert( is_object<_Tp>::value, "pointer to object type" ); 689 #endif 690 return _M_b.fetch_sub(__d, __m); 691 } 692 693 __pointer_type 694 fetch_sub(ptrdiff_t __d, 695 memory_order __m = memory_order_seq_cst) volatile noexcept 696 { 697 #if __cplusplus >= 201703L 698 static_assert( is_object<_Tp>::value, "pointer to object type" ); 699 #endif 700 return _M_b.fetch_sub(__d, __m); 701 } 702 }; 703 704 705 /// Explicit specialization for char. 706 template<> 707 struct atomic<char> : __atomic_base<char> 708 { 709 typedef char __integral_type; 710 typedef __atomic_base<char> __base_type; 711 712 atomic() noexcept = default; 713 ~atomic() noexcept = default; 714 atomic(const atomic&) = delete; 715 atomic& operator=(const atomic&) = delete; 716 atomic& operator=(const atomic&) volatile = delete; 717 718 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 719 720 using __base_type::operator __integral_type; 721 using __base_type::operator=; 722 723 #if __cplusplus >= 201703L 724 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; 725 #endif 726 }; 727 728 /// Explicit specialization for signed char. 729 template<> 730 struct atomic<signed char> : __atomic_base<signed char> 731 { 732 typedef signed char __integral_type; 733 typedef __atomic_base<signed char> __base_type; 734 735 atomic() noexcept= default; 736 ~atomic() noexcept = default; 737 atomic(const atomic&) = delete; 738 atomic& operator=(const atomic&) = delete; 739 atomic& operator=(const atomic&) volatile = delete; 740 741 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 742 743 using __base_type::operator __integral_type; 744 using __base_type::operator=; 745 746 #if __cplusplus >= 201703L 747 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; 748 #endif 749 }; 750 751 /// Explicit specialization for unsigned char. 752 template<> 753 struct atomic<unsigned char> : __atomic_base<unsigned char> 754 { 755 typedef unsigned char __integral_type; 756 typedef __atomic_base<unsigned char> __base_type; 757 758 atomic() noexcept= default; 759 ~atomic() noexcept = default; 760 atomic(const atomic&) = delete; 761 atomic& operator=(const atomic&) = delete; 762 atomic& operator=(const atomic&) volatile = delete; 763 764 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 765 766 using __base_type::operator __integral_type; 767 using __base_type::operator=; 768 769 #if __cplusplus >= 201703L 770 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; 771 #endif 772 }; 773 774 /// Explicit specialization for short. 775 template<> 776 struct atomic<short> : __atomic_base<short> 777 { 778 typedef short __integral_type; 779 typedef __atomic_base<short> __base_type; 780 781 atomic() noexcept = default; 782 ~atomic() noexcept = default; 783 atomic(const atomic&) = delete; 784 atomic& operator=(const atomic&) = delete; 785 atomic& operator=(const atomic&) volatile = delete; 786 787 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 788 789 using __base_type::operator __integral_type; 790 using __base_type::operator=; 791 792 #if __cplusplus >= 201703L 793 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2; 794 #endif 795 }; 796 797 /// Explicit specialization for unsigned short. 798 template<> 799 struct atomic<unsigned short> : __atomic_base<unsigned short> 800 { 801 typedef unsigned short __integral_type; 802 typedef __atomic_base<unsigned short> __base_type; 803 804 atomic() noexcept = default; 805 ~atomic() noexcept = default; 806 atomic(const atomic&) = delete; 807 atomic& operator=(const atomic&) = delete; 808 atomic& operator=(const atomic&) volatile = delete; 809 810 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 811 812 using __base_type::operator __integral_type; 813 using __base_type::operator=; 814 815 #if __cplusplus >= 201703L 816 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2; 817 #endif 818 }; 819 820 /// Explicit specialization for int. 821 template<> 822 struct atomic<int> : __atomic_base<int> 823 { 824 typedef int __integral_type; 825 typedef __atomic_base<int> __base_type; 826 827 atomic() noexcept = default; 828 ~atomic() noexcept = default; 829 atomic(const atomic&) = delete; 830 atomic& operator=(const atomic&) = delete; 831 atomic& operator=(const atomic&) volatile = delete; 832 833 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 834 835 using __base_type::operator __integral_type; 836 using __base_type::operator=; 837 838 #if __cplusplus >= 201703L 839 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2; 840 #endif 841 }; 842 843 /// Explicit specialization for unsigned int. 844 template<> 845 struct atomic<unsigned int> : __atomic_base<unsigned int> 846 { 847 typedef unsigned int __integral_type; 848 typedef __atomic_base<unsigned int> __base_type; 849 850 atomic() noexcept = default; 851 ~atomic() noexcept = default; 852 atomic(const atomic&) = delete; 853 atomic& operator=(const atomic&) = delete; 854 atomic& operator=(const atomic&) volatile = delete; 855 856 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 857 858 using __base_type::operator __integral_type; 859 using __base_type::operator=; 860 861 #if __cplusplus >= 201703L 862 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2; 863 #endif 864 }; 865 866 /// Explicit specialization for long. 867 template<> 868 struct atomic<long> : __atomic_base<long> 869 { 870 typedef long __integral_type; 871 typedef __atomic_base<long> __base_type; 872 873 atomic() noexcept = default; 874 ~atomic() noexcept = default; 875 atomic(const atomic&) = delete; 876 atomic& operator=(const atomic&) = delete; 877 atomic& operator=(const atomic&) volatile = delete; 878 879 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 880 881 using __base_type::operator __integral_type; 882 using __base_type::operator=; 883 884 #if __cplusplus >= 201703L 885 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2; 886 #endif 887 }; 888 889 /// Explicit specialization for unsigned long. 890 template<> 891 struct atomic<unsigned long> : __atomic_base<unsigned long> 892 { 893 typedef unsigned long __integral_type; 894 typedef __atomic_base<unsigned long> __base_type; 895 896 atomic() noexcept = default; 897 ~atomic() noexcept = default; 898 atomic(const atomic&) = delete; 899 atomic& operator=(const atomic&) = delete; 900 atomic& operator=(const atomic&) volatile = delete; 901 902 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 903 904 using __base_type::operator __integral_type; 905 using __base_type::operator=; 906 907 #if __cplusplus >= 201703L 908 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2; 909 #endif 910 }; 911 912 /// Explicit specialization for long long. 913 template<> 914 struct atomic<long long> : __atomic_base<long long> 915 { 916 typedef long long __integral_type; 917 typedef __atomic_base<long long> __base_type; 918 919 atomic() noexcept = default; 920 ~atomic() noexcept = default; 921 atomic(const atomic&) = delete; 922 atomic& operator=(const atomic&) = delete; 923 atomic& operator=(const atomic&) volatile = delete; 924 925 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 926 927 using __base_type::operator __integral_type; 928 using __base_type::operator=; 929 930 #if __cplusplus >= 201703L 931 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2; 932 #endif 933 }; 934 935 /// Explicit specialization for unsigned long long. 936 template<> 937 struct atomic<unsigned long long> : __atomic_base<unsigned long long> 938 { 939 typedef unsigned long long __integral_type; 940 typedef __atomic_base<unsigned long long> __base_type; 941 942 atomic() noexcept = default; 943 ~atomic() noexcept = default; 944 atomic(const atomic&) = delete; 945 atomic& operator=(const atomic&) = delete; 946 atomic& operator=(const atomic&) volatile = delete; 947 948 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 949 950 using __base_type::operator __integral_type; 951 using __base_type::operator=; 952 953 #if __cplusplus >= 201703L 954 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2; 955 #endif 956 }; 957 958 /// Explicit specialization for wchar_t. 959 template<> 960 struct atomic<wchar_t> : __atomic_base<wchar_t> 961 { 962 typedef wchar_t __integral_type; 963 typedef __atomic_base<wchar_t> __base_type; 964 965 atomic() noexcept = default; 966 ~atomic() noexcept = default; 967 atomic(const atomic&) = delete; 968 atomic& operator=(const atomic&) = delete; 969 atomic& operator=(const atomic&) volatile = delete; 970 971 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 972 973 using __base_type::operator __integral_type; 974 using __base_type::operator=; 975 976 #if __cplusplus >= 201703L 977 static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2; 978 #endif 979 }; 980 981 #ifdef _GLIBCXX_USE_CHAR8_T 982 /// Explicit specialization for char8_t. 983 template<> 984 struct atomic<char8_t> : __atomic_base<char8_t> 985 { 986 typedef char8_t __integral_type; 987 typedef __atomic_base<char8_t> __base_type; 988 989 atomic() noexcept = default; 990 ~atomic() noexcept = default; 991 atomic(const atomic&) = delete; 992 atomic& operator=(const atomic&) = delete; 993 atomic& operator=(const atomic&) volatile = delete; 994 995 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 996 997 using __base_type::operator __integral_type; 998 using __base_type::operator=; 999 1000 #if __cplusplus > 201402L 1001 static constexpr bool is_always_lock_free 1002 = ATOMIC_CHAR8_T_LOCK_FREE == 2; 1003 #endif 1004 }; 1005 #endif 1006 1007 /// Explicit specialization for char16_t. 1008 template<> 1009 struct atomic<char16_t> : __atomic_base<char16_t> 1010 { 1011 typedef char16_t __integral_type; 1012 typedef __atomic_base<char16_t> __base_type; 1013 1014 atomic() noexcept = default; 1015 ~atomic() noexcept = default; 1016 atomic(const atomic&) = delete; 1017 atomic& operator=(const atomic&) = delete; 1018 atomic& operator=(const atomic&) volatile = delete; 1019 1020 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 1021 1022 using __base_type::operator __integral_type; 1023 using __base_type::operator=; 1024 1025 #if __cplusplus >= 201703L 1026 static constexpr bool is_always_lock_free 1027 = ATOMIC_CHAR16_T_LOCK_FREE == 2; 1028 #endif 1029 }; 1030 1031 /// Explicit specialization for char32_t. 1032 template<> 1033 struct atomic<char32_t> : __atomic_base<char32_t> 1034 { 1035 typedef char32_t __integral_type; 1036 typedef __atomic_base<char32_t> __base_type; 1037 1038 atomic() noexcept = default; 1039 ~atomic() noexcept = default; 1040 atomic(const atomic&) = delete; 1041 atomic& operator=(const atomic&) = delete; 1042 atomic& operator=(const atomic&) volatile = delete; 1043 1044 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 1045 1046 using __base_type::operator __integral_type; 1047 using __base_type::operator=; 1048 1049 #if __cplusplus >= 201703L 1050 static constexpr bool is_always_lock_free 1051 = ATOMIC_CHAR32_T_LOCK_FREE == 2; 1052 #endif 1053 }; 1054 1055 1056 /// atomic_bool 1057 typedef atomic<bool> atomic_bool; 1058 1059 /// atomic_char 1060 typedef atomic<char> atomic_char; 1061 1062 /// atomic_schar 1063 typedef atomic<signed char> atomic_schar; 1064 1065 /// atomic_uchar 1066 typedef atomic<unsigned char> atomic_uchar; 1067 1068 /// atomic_short 1069 typedef atomic<short> atomic_short; 1070 1071 /// atomic_ushort 1072 typedef atomic<unsigned short> atomic_ushort; 1073 1074 /// atomic_int 1075 typedef atomic<int> atomic_int; 1076 1077 /// atomic_uint 1078 typedef atomic<unsigned int> atomic_uint; 1079 1080 /// atomic_long 1081 typedef atomic<long> atomic_long; 1082 1083 /// atomic_ulong 1084 typedef atomic<unsigned long> atomic_ulong; 1085 1086 /// atomic_llong 1087 typedef atomic<long long> atomic_llong; 1088 1089 /// atomic_ullong 1090 typedef atomic<unsigned long long> atomic_ullong; 1091 1092 /// atomic_wchar_t 1093 typedef atomic<wchar_t> atomic_wchar_t; 1094 1095 #ifdef _GLIBCXX_USE_CHAR8_T 1096 /// atomic_char8_t 1097 typedef atomic<char8_t> atomic_char8_t; 1098 #endif 1099 1100 /// atomic_char16_t 1101 typedef atomic<char16_t> atomic_char16_t; 1102 1103 /// atomic_char32_t 1104 typedef atomic<char32_t> atomic_char32_t; 1105 1106 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 1107 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1108 // 2441. Exact-width atomic typedefs should be provided 1109 1110 /// atomic_int8_t 1111 typedef atomic<int8_t> atomic_int8_t; 1112 1113 /// atomic_uint8_t 1114 typedef atomic<uint8_t> atomic_uint8_t; 1115 1116 /// atomic_int16_t 1117 typedef atomic<int16_t> atomic_int16_t; 1118 1119 /// atomic_uint16_t 1120 typedef atomic<uint16_t> atomic_uint16_t; 1121 1122 /// atomic_int32_t 1123 typedef atomic<int32_t> atomic_int32_t; 1124 1125 /// atomic_uint32_t 1126 typedef atomic<uint32_t> atomic_uint32_t; 1127 1128 /// atomic_int64_t 1129 typedef atomic<int64_t> atomic_int64_t; 1130 1131 /// atomic_uint64_t 1132 typedef atomic<uint64_t> atomic_uint64_t; 1133 1134 1135 /// atomic_int_least8_t 1136 typedef atomic<int_least8_t> atomic_int_least8_t; 1137 1138 /// atomic_uint_least8_t 1139 typedef atomic<uint_least8_t> atomic_uint_least8_t; 1140 1141 /// atomic_int_least16_t 1142 typedef atomic<int_least16_t> atomic_int_least16_t; 1143 1144 /// atomic_uint_least16_t 1145 typedef atomic<uint_least16_t> atomic_uint_least16_t; 1146 1147 /// atomic_int_least32_t 1148 typedef atomic<int_least32_t> atomic_int_least32_t; 1149 1150 /// atomic_uint_least32_t 1151 typedef atomic<uint_least32_t> atomic_uint_least32_t; 1152 1153 /// atomic_int_least64_t 1154 typedef atomic<int_least64_t> atomic_int_least64_t; 1155 1156 /// atomic_uint_least64_t 1157 typedef atomic<uint_least64_t> atomic_uint_least64_t; 1158 1159 1160 /// atomic_int_fast8_t 1161 typedef atomic<int_fast8_t> atomic_int_fast8_t; 1162 1163 /// atomic_uint_fast8_t 1164 typedef atomic<uint_fast8_t> atomic_uint_fast8_t; 1165 1166 /// atomic_int_fast16_t 1167 typedef atomic<int_fast16_t> atomic_int_fast16_t; 1168 1169 /// atomic_uint_fast16_t 1170 typedef atomic<uint_fast16_t> atomic_uint_fast16_t; 1171 1172 /// atomic_int_fast32_t 1173 typedef atomic<int_fast32_t> atomic_int_fast32_t; 1174 1175 /// atomic_uint_fast32_t 1176 typedef atomic<uint_fast32_t> atomic_uint_fast32_t; 1177 1178 /// atomic_int_fast64_t 1179 typedef atomic<int_fast64_t> atomic_int_fast64_t; 1180 1181 /// atomic_uint_fast64_t 1182 typedef atomic<uint_fast64_t> atomic_uint_fast64_t; 1183 #endif 1184 1185 1186 /// atomic_intptr_t 1187 typedef atomic<intptr_t> atomic_intptr_t; 1188 1189 /// atomic_uintptr_t 1190 typedef atomic<uintptr_t> atomic_uintptr_t; 1191 1192 /// atomic_size_t 1193 typedef atomic<size_t> atomic_size_t; 1194 1195 /// atomic_ptrdiff_t 1196 typedef atomic<ptrdiff_t> atomic_ptrdiff_t; 1197 1198 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 1199 /// atomic_intmax_t 1200 typedef atomic<intmax_t> atomic_intmax_t; 1201 1202 /// atomic_uintmax_t 1203 typedef atomic<uintmax_t> atomic_uintmax_t; 1204 #endif 1205 1206 // Function definitions, atomic_flag operations. 1207 inline bool 1208 atomic_flag_test_and_set_explicit(atomic_flag* __a, 1209 memory_order __m) noexcept 1210 { return __a->test_and_set(__m); } 1211 1212 inline bool 1213 atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, 1214 memory_order __m) noexcept 1215 { return __a->test_and_set(__m); } 1216 1217 #if __cpp_lib_atomic_flag_test 1218 inline bool 1219 atomic_flag_test(const atomic_flag* __a) noexcept 1220 { return __a->test(); } 1221 1222 inline bool 1223 atomic_flag_test(const volatile atomic_flag* __a) noexcept 1224 { return __a->test(); } 1225 1226 inline bool 1227 atomic_flag_test_explicit(const atomic_flag* __a, 1228 memory_order __m) noexcept 1229 { return __a->test(__m); } 1230 1231 inline bool 1232 atomic_flag_test_explicit(const volatile atomic_flag* __a, 1233 memory_order __m) noexcept 1234 { return __a->test(__m); } 1235 #endif 1236 1237 inline void 1238 atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept 1239 { __a->clear(__m); } 1240 1241 inline void 1242 atomic_flag_clear_explicit(volatile atomic_flag* __a, 1243 memory_order __m) noexcept 1244 { __a->clear(__m); } 1245 1246 inline bool 1247 atomic_flag_test_and_set(atomic_flag* __a) noexcept 1248 { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } 1249 1250 inline bool 1251 atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept 1252 { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } 1253 1254 inline void 1255 atomic_flag_clear(atomic_flag* __a) noexcept 1256 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } 1257 1258 inline void 1259 atomic_flag_clear(volatile atomic_flag* __a) noexcept 1260 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } 1261 1262 #if __cpp_lib_atomic_wait 1263 inline void 1264 atomic_flag_wait(atomic_flag* __a, bool __old) noexcept 1265 { __a->wait(__old); } 1266 1267 inline void 1268 atomic_flag_wait_explicit(atomic_flag* __a, bool __old, 1269 memory_order __m) noexcept 1270 { __a->wait(__old, __m); } 1271 1272 inline void 1273 atomic_flag_notify_one(atomic_flag* __a) noexcept 1274 { __a->notify_one(); } 1275 1276 inline void 1277 atomic_flag_notify_all(atomic_flag* __a) noexcept 1278 { __a->notify_all(); } 1279 #endif // __cpp_lib_atomic_wait 1280 1281 /// @cond undocumented 1282 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1283 // 3220. P0558 broke conforming C++14 uses of atomic shared_ptr 1284 template<typename _Tp> 1285 using __atomic_val_t = __type_identity_t<_Tp>; 1286 template<typename _Tp> 1287 using __atomic_diff_t = typename atomic<_Tp>::difference_type; 1288 /// @endcond 1289 1290 // [atomics.nonmembers] Non-member functions. 1291 // Function templates generally applicable to atomic types. 1292 template<typename _ITp> 1293 inline bool 1294 atomic_is_lock_free(const atomic<_ITp>* __a) noexcept 1295 { return __a->is_lock_free(); } 1296 1297 template<typename _ITp> 1298 inline bool 1299 atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept 1300 { return __a->is_lock_free(); } 1301 1302 template<typename _ITp> 1303 inline void 1304 atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1305 { __a->store(__i, memory_order_relaxed); } 1306 1307 template<typename _ITp> 1308 inline void 1309 atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1310 { __a->store(__i, memory_order_relaxed); } 1311 1312 template<typename _ITp> 1313 inline void 1314 atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, 1315 memory_order __m) noexcept 1316 { __a->store(__i, __m); } 1317 1318 template<typename _ITp> 1319 inline void 1320 atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, 1321 memory_order __m) noexcept 1322 { __a->store(__i, __m); } 1323 1324 template<typename _ITp> 1325 inline _ITp 1326 atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept 1327 { return __a->load(__m); } 1328 1329 template<typename _ITp> 1330 inline _ITp 1331 atomic_load_explicit(const volatile atomic<_ITp>* __a, 1332 memory_order __m) noexcept 1333 { return __a->load(__m); } 1334 1335 template<typename _ITp> 1336 inline _ITp 1337 atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, 1338 memory_order __m) noexcept 1339 { return __a->exchange(__i, __m); } 1340 1341 template<typename _ITp> 1342 inline _ITp 1343 atomic_exchange_explicit(volatile atomic<_ITp>* __a, 1344 __atomic_val_t<_ITp> __i, 1345 memory_order __m) noexcept 1346 { return __a->exchange(__i, __m); } 1347 1348 template<typename _ITp> 1349 inline bool 1350 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, 1351 __atomic_val_t<_ITp>* __i1, 1352 __atomic_val_t<_ITp> __i2, 1353 memory_order __m1, 1354 memory_order __m2) noexcept 1355 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } 1356 1357 template<typename _ITp> 1358 inline bool 1359 atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, 1360 __atomic_val_t<_ITp>* __i1, 1361 __atomic_val_t<_ITp> __i2, 1362 memory_order __m1, 1363 memory_order __m2) noexcept 1364 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } 1365 1366 template<typename _ITp> 1367 inline bool 1368 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, 1369 __atomic_val_t<_ITp>* __i1, 1370 __atomic_val_t<_ITp> __i2, 1371 memory_order __m1, 1372 memory_order __m2) noexcept 1373 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } 1374 1375 template<typename _ITp> 1376 inline bool 1377 atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, 1378 __atomic_val_t<_ITp>* __i1, 1379 __atomic_val_t<_ITp> __i2, 1380 memory_order __m1, 1381 memory_order __m2) noexcept 1382 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } 1383 1384 1385 template<typename _ITp> 1386 inline void 1387 atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1388 { atomic_store_explicit(__a, __i, memory_order_seq_cst); } 1389 1390 template<typename _ITp> 1391 inline void 1392 atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1393 { atomic_store_explicit(__a, __i, memory_order_seq_cst); } 1394 1395 template<typename _ITp> 1396 inline _ITp 1397 atomic_load(const atomic<_ITp>* __a) noexcept 1398 { return atomic_load_explicit(__a, memory_order_seq_cst); } 1399 1400 template<typename _ITp> 1401 inline _ITp 1402 atomic_load(const volatile atomic<_ITp>* __a) noexcept 1403 { return atomic_load_explicit(__a, memory_order_seq_cst); } 1404 1405 template<typename _ITp> 1406 inline _ITp 1407 atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1408 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } 1409 1410 template<typename _ITp> 1411 inline _ITp 1412 atomic_exchange(volatile atomic<_ITp>* __a, 1413 __atomic_val_t<_ITp> __i) noexcept 1414 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } 1415 1416 template<typename _ITp> 1417 inline bool 1418 atomic_compare_exchange_weak(atomic<_ITp>* __a, 1419 __atomic_val_t<_ITp>* __i1, 1420 __atomic_val_t<_ITp> __i2) noexcept 1421 { 1422 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, 1423 memory_order_seq_cst, 1424 memory_order_seq_cst); 1425 } 1426 1427 template<typename _ITp> 1428 inline bool 1429 atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, 1430 __atomic_val_t<_ITp>* __i1, 1431 __atomic_val_t<_ITp> __i2) noexcept 1432 { 1433 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, 1434 memory_order_seq_cst, 1435 memory_order_seq_cst); 1436 } 1437 1438 template<typename _ITp> 1439 inline bool 1440 atomic_compare_exchange_strong(atomic<_ITp>* __a, 1441 __atomic_val_t<_ITp>* __i1, 1442 __atomic_val_t<_ITp> __i2) noexcept 1443 { 1444 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, 1445 memory_order_seq_cst, 1446 memory_order_seq_cst); 1447 } 1448 1449 template<typename _ITp> 1450 inline bool 1451 atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, 1452 __atomic_val_t<_ITp>* __i1, 1453 __atomic_val_t<_ITp> __i2) noexcept 1454 { 1455 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, 1456 memory_order_seq_cst, 1457 memory_order_seq_cst); 1458 } 1459 1460 1461 #if __cpp_lib_atomic_wait 1462 template<typename _Tp> 1463 inline void 1464 atomic_wait(const atomic<_Tp>* __a, 1465 typename std::atomic<_Tp>::value_type __old) noexcept 1466 { __a->wait(__old); } 1467 1468 template<typename _Tp> 1469 inline void 1470 atomic_wait_explicit(const atomic<_Tp>* __a, 1471 typename std::atomic<_Tp>::value_type __old, 1472 std::memory_order __m) noexcept 1473 { __a->wait(__old, __m); } 1474 1475 template<typename _Tp> 1476 inline void 1477 atomic_notify_one(atomic<_Tp>* __a) noexcept 1478 { __a->notify_one(); } 1479 1480 template<typename _Tp> 1481 inline void 1482 atomic_notify_all(atomic<_Tp>* __a) noexcept 1483 { __a->notify_all(); } 1484 #endif // __cpp_lib_atomic_wait 1485 1486 // Function templates for atomic_integral and atomic_pointer operations only. 1487 // Some operations (and, or, xor) are only available for atomic integrals, 1488 // which is implemented by taking a parameter of type __atomic_base<_ITp>*. 1489 1490 template<typename _ITp> 1491 inline _ITp 1492 atomic_fetch_add_explicit(atomic<_ITp>* __a, 1493 __atomic_diff_t<_ITp> __i, 1494 memory_order __m) noexcept 1495 { return __a->fetch_add(__i, __m); } 1496 1497 template<typename _ITp> 1498 inline _ITp 1499 atomic_fetch_add_explicit(volatile atomic<_ITp>* __a, 1500 __atomic_diff_t<_ITp> __i, 1501 memory_order __m) noexcept 1502 { return __a->fetch_add(__i, __m); } 1503 1504 template<typename _ITp> 1505 inline _ITp 1506 atomic_fetch_sub_explicit(atomic<_ITp>* __a, 1507 __atomic_diff_t<_ITp> __i, 1508 memory_order __m) noexcept 1509 { return __a->fetch_sub(__i, __m); } 1510 1511 template<typename _ITp> 1512 inline _ITp 1513 atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a, 1514 __atomic_diff_t<_ITp> __i, 1515 memory_order __m) noexcept 1516 { return __a->fetch_sub(__i, __m); } 1517 1518 template<typename _ITp> 1519 inline _ITp 1520 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, 1521 __atomic_val_t<_ITp> __i, 1522 memory_order __m) noexcept 1523 { return __a->fetch_and(__i, __m); } 1524 1525 template<typename _ITp> 1526 inline _ITp 1527 atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, 1528 __atomic_val_t<_ITp> __i, 1529 memory_order __m) noexcept 1530 { return __a->fetch_and(__i, __m); } 1531 1532 template<typename _ITp> 1533 inline _ITp 1534 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, 1535 __atomic_val_t<_ITp> __i, 1536 memory_order __m) noexcept 1537 { return __a->fetch_or(__i, __m); } 1538 1539 template<typename _ITp> 1540 inline _ITp 1541 atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, 1542 __atomic_val_t<_ITp> __i, 1543 memory_order __m) noexcept 1544 { return __a->fetch_or(__i, __m); } 1545 1546 template<typename _ITp> 1547 inline _ITp 1548 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, 1549 __atomic_val_t<_ITp> __i, 1550 memory_order __m) noexcept 1551 { return __a->fetch_xor(__i, __m); } 1552 1553 template<typename _ITp> 1554 inline _ITp 1555 atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, 1556 __atomic_val_t<_ITp> __i, 1557 memory_order __m) noexcept 1558 { return __a->fetch_xor(__i, __m); } 1559 1560 template<typename _ITp> 1561 inline _ITp 1562 atomic_fetch_add(atomic<_ITp>* __a, 1563 __atomic_diff_t<_ITp> __i) noexcept 1564 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } 1565 1566 template<typename _ITp> 1567 inline _ITp 1568 atomic_fetch_add(volatile atomic<_ITp>* __a, 1569 __atomic_diff_t<_ITp> __i) noexcept 1570 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } 1571 1572 template<typename _ITp> 1573 inline _ITp 1574 atomic_fetch_sub(atomic<_ITp>* __a, 1575 __atomic_diff_t<_ITp> __i) noexcept 1576 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } 1577 1578 template<typename _ITp> 1579 inline _ITp 1580 atomic_fetch_sub(volatile atomic<_ITp>* __a, 1581 __atomic_diff_t<_ITp> __i) noexcept 1582 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } 1583 1584 template<typename _ITp> 1585 inline _ITp 1586 atomic_fetch_and(__atomic_base<_ITp>* __a, 1587 __atomic_val_t<_ITp> __i) noexcept 1588 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } 1589 1590 template<typename _ITp> 1591 inline _ITp 1592 atomic_fetch_and(volatile __atomic_base<_ITp>* __a, 1593 __atomic_val_t<_ITp> __i) noexcept 1594 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } 1595 1596 template<typename _ITp> 1597 inline _ITp 1598 atomic_fetch_or(__atomic_base<_ITp>* __a, 1599 __atomic_val_t<_ITp> __i) noexcept 1600 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } 1601 1602 template<typename _ITp> 1603 inline _ITp 1604 atomic_fetch_or(volatile __atomic_base<_ITp>* __a, 1605 __atomic_val_t<_ITp> __i) noexcept 1606 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } 1607 1608 template<typename _ITp> 1609 inline _ITp 1610 atomic_fetch_xor(__atomic_base<_ITp>* __a, 1611 __atomic_val_t<_ITp> __i) noexcept 1612 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } 1613 1614 template<typename _ITp> 1615 inline _ITp 1616 atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, 1617 __atomic_val_t<_ITp> __i) noexcept 1618 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } 1619 1620 #if __cplusplus > 201703L 1621 #define __cpp_lib_atomic_float 201711L 1622 template<> 1623 struct atomic<float> : __atomic_float<float> 1624 { 1625 atomic() noexcept = default; 1626 1627 constexpr 1628 atomic(float __fp) noexcept : __atomic_float<float>(__fp) 1629 { } 1630 1631 atomic& operator=(const atomic&) volatile = delete; 1632 atomic& operator=(const atomic&) = delete; 1633 1634 using __atomic_float<float>::operator=; 1635 }; 1636 1637 template<> 1638 struct atomic<double> : __atomic_float<double> 1639 { 1640 atomic() noexcept = default; 1641 1642 constexpr 1643 atomic(double __fp) noexcept : __atomic_float<double>(__fp) 1644 { } 1645 1646 atomic& operator=(const atomic&) volatile = delete; 1647 atomic& operator=(const atomic&) = delete; 1648 1649 using __atomic_float<double>::operator=; 1650 }; 1651 1652 template<> 1653 struct atomic<long double> : __atomic_float<long double> 1654 { 1655 atomic() noexcept = default; 1656 1657 constexpr 1658 atomic(long double __fp) noexcept : __atomic_float<long double>(__fp) 1659 { } 1660 1661 atomic& operator=(const atomic&) volatile = delete; 1662 atomic& operator=(const atomic&) = delete; 1663 1664 using __atomic_float<long double>::operator=; 1665 }; 1666 1667 #ifdef __STDCPP_FLOAT16_T__ 1668 template<> 1669 struct atomic<_Float16> : __atomic_float<_Float16> 1670 { 1671 atomic() noexcept = default; 1672 1673 constexpr 1674 atomic(_Float16 __fp) noexcept : __atomic_float<_Float16>(__fp) 1675 { } 1676 1677 atomic& operator=(const atomic&) volatile = delete; 1678 atomic& operator=(const atomic&) = delete; 1679 1680 using __atomic_float<_Float16>::operator=; 1681 }; 1682 #endif 1683 1684 #ifdef __STDCPP_FLOAT32_T__ 1685 template<> 1686 struct atomic<_Float32> : __atomic_float<_Float32> 1687 { 1688 atomic() noexcept = default; 1689 1690 constexpr 1691 atomic(_Float32 __fp) noexcept : __atomic_float<_Float32>(__fp) 1692 { } 1693 1694 atomic& operator=(const atomic&) volatile = delete; 1695 atomic& operator=(const atomic&) = delete; 1696 1697 using __atomic_float<_Float32>::operator=; 1698 }; 1699 #endif 1700 1701 #ifdef __STDCPP_FLOAT64_T__ 1702 template<> 1703 struct atomic<_Float64> : __atomic_float<_Float64> 1704 { 1705 atomic() noexcept = default; 1706 1707 constexpr 1708 atomic(_Float64 __fp) noexcept : __atomic_float<_Float64>(__fp) 1709 { } 1710 1711 atomic& operator=(const atomic&) volatile = delete; 1712 atomic& operator=(const atomic&) = delete; 1713 1714 using __atomic_float<_Float64>::operator=; 1715 }; 1716 #endif 1717 1718 #ifdef __STDCPP_FLOAT128_T__ 1719 template<> 1720 struct atomic<_Float128> : __atomic_float<_Float128> 1721 { 1722 atomic() noexcept = default; 1723 1724 constexpr 1725 atomic(_Float128 __fp) noexcept : __atomic_float<_Float128>(__fp) 1726 { } 1727 1728 atomic& operator=(const atomic&) volatile = delete; 1729 atomic& operator=(const atomic&) = delete; 1730 1731 using __atomic_float<_Float128>::operator=; 1732 }; 1733 #endif 1734 1735 #ifdef __STDCPP_BFLOAT16_T__ 1736 template<> 1737 struct atomic<__gnu_cxx::__bfloat16_t> : __atomic_float<__gnu_cxx::__bfloat16_t> 1738 { 1739 atomic() noexcept = default; 1740 1741 constexpr 1742 atomic(__gnu_cxx::__bfloat16_t __fp) noexcept : __atomic_float<__gnu_cxx::__bfloat16_t>(__fp) 1743 { } 1744 1745 atomic& operator=(const atomic&) volatile = delete; 1746 atomic& operator=(const atomic&) = delete; 1747 1748 using __atomic_float<__gnu_cxx::__bfloat16_t>::operator=; 1749 }; 1750 #endif 1751 1752 #define __cpp_lib_atomic_ref 201806L 1753 1754 /// Class template to provide atomic operations on a non-atomic variable. 1755 template<typename _Tp> 1756 struct atomic_ref : __atomic_ref<_Tp> 1757 { 1758 explicit 1759 atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t) 1760 { } 1761 1762 atomic_ref& operator=(const atomic_ref&) = delete; 1763 1764 atomic_ref(const atomic_ref&) = default; 1765 1766 using __atomic_ref<_Tp>::operator=; 1767 }; 1768 1769 #define __cpp_lib_atomic_lock_free_type_aliases 201907L 1770 #ifdef _GLIBCXX_HAVE_PLATFORM_WAIT 1771 using atomic_signed_lock_free 1772 = atomic<make_signed_t<__detail::__platform_wait_t>>; 1773 using atomic_unsigned_lock_free 1774 = atomic<make_unsigned_t<__detail::__platform_wait_t>>; 1775 #elif ATOMIC_INT_LOCK_FREE || !(ATOMIC_LONG_LOCK_FREE || ATOMIC_CHAR_LOCK_FREE) 1776 using atomic_signed_lock_free = atomic<signed int>; 1777 using atomic_unsigned_lock_free = atomic<unsigned int>; 1778 #elif ATOMIC_LONG_LOCK_FREE 1779 using atomic_signed_lock_free = atomic<signed long>; 1780 using atomic_unsigned_lock_free = atomic<unsigned long>; 1781 #elif ATOMIC_CHAR_LOCK_FREE 1782 using atomic_signed_lock_free = atomic<signed char>; 1783 using atomic_unsigned_lock_free = atomic<unsigned char>; 1784 #endif 1785 1786 #endif // C++2a 1787 1788 /// @} group atomics 1789 1790 _GLIBCXX_END_NAMESPACE_VERSION 1791 } // namespace 1792 1793 #endif // C++11 1794 1795 #endif // _GLIBCXX_ATOMIC
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
