[libc++] Implement C++20 atomic_ref (#76647)
Implement the std::atomic_ref class template by reusing atomic_base_impl. Based on the work from https://reviews.llvm.org/D72240
This commit is contained in:
Damien L-G
@@ -53,6 +53,7 @@ Implemented Papers
|
||||
- P2387R3 - Pipe support for user-defined range adaptors
|
||||
- P2713R1 - Escaping improvements in ``std::format``
|
||||
- P2231R1 - Missing ``constexpr`` in ``std::optional`` and ``std::variant``
|
||||
- P0019R8 - ``std::atomic_ref``
|
||||
|
||||
Improvements and New Features
|
||||
-----------------------------
|
||||
|
||||
@@ -26,7 +26,7 @@
|
||||
"`P0905R1 <https://wg21.link/P0905R1>`__","CWG","Symmetry for spaceship","Jacksonville","|Complete|","7.0","|spaceship|"
|
||||
"`P0966R1 <https://wg21.link/P0966R1>`__","LWG","``string::reserve``\ Should Not Shrink","Jacksonville","|Complete| [#note-P0966]_","12.0"
|
||||
"","","","","","",""
|
||||
"`P0019R8 <https://wg21.link/P0019R8>`__","LWG","Atomic Ref","Rapperswil","",""
|
||||
"`P0019R8 <https://wg21.link/P0019R8>`__","LWG","Atomic Ref","Rapperswil","|Complete|","19.0"
|
||||
"`P0458R2 <https://wg21.link/P0458R2>`__","LWG","Checking for Existence of an Element in Associative Containers","Rapperswil","|Complete|","13.0"
|
||||
"`P0475R1 <https://wg21.link/P0475R1>`__","LWG","LWG 2511: guaranteed copy elision for piecewise construction","Rapperswil","|Complete|",""
|
||||
"`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","|Complete|","14.0"
|
||||
@@ -125,7 +125,7 @@
|
||||
"`P1612R1 <https://wg21.link/P1612R1>`__","LWG","Relocate Endian's Specification","Cologne","|Complete|","10.0"
|
||||
"`P1614R2 <https://wg21.link/P1614R2>`__","LWG","The Mothership has Landed","Cologne","|In Progress|",""
|
||||
"`P1638R1 <https://wg21.link/P1638R1>`__","LWG","basic_istream_view::iterator should not be copyable","Cologne","|Complete|","16.0","|ranges|"
|
||||
"`P1643R1 <https://wg21.link/P1643R1>`__","LWG","Add wait/notify to atomic_ref","Cologne","",""
|
||||
"`P1643R1 <https://wg21.link/P1643R1>`__","LWG","Add wait/notify to atomic_ref","Cologne","|Complete|","19.0"
|
||||
"`P1644R0 <https://wg21.link/P1644R0>`__","LWG","Add wait/notify to atomic<shared_ptr>","Cologne","",""
|
||||
"`P1650R0 <https://wg21.link/P1650R0>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","|Complete|","16.0"
|
||||
"`P1651R0 <https://wg21.link/P1651R0>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","|Complete|","13.0"
|
||||
|
||||
|
@@ -224,6 +224,7 @@ set(files
|
||||
__atomic/atomic_flag.h
|
||||
__atomic/atomic_init.h
|
||||
__atomic/atomic_lock_free.h
|
||||
__atomic/atomic_ref.h
|
||||
__atomic/atomic_sync.h
|
||||
__atomic/check_memory_order.h
|
||||
__atomic/contention_t.h
|
||||
@@ -232,6 +233,7 @@ set(files
|
||||
__atomic/is_always_lock_free.h
|
||||
__atomic/kill_dependency.h
|
||||
__atomic/memory_order.h
|
||||
__atomic/to_gcc_order.h
|
||||
__availability
|
||||
__bit/bit_cast.h
|
||||
__bit/bit_ceil.h
|
||||
|
||||
360
libcxx/include/__atomic/atomic_ref.h
Normal file
360
libcxx/include/__atomic/atomic_ref.h
Normal file
@@ -0,0 +1,360 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
// Kokkos v. 4.0
|
||||
// Copyright (2022) National Technology & Engineering
|
||||
// Solutions of Sandia, LLC (NTESS).
|
||||
//
|
||||
// Under the terms of Contract DE-NA0003525 with NTESS,
|
||||
// the U.S. Government retains certain rights in this software.
|
||||
//
|
||||
//===---------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___ATOMIC_ATOMIC_REF_H
|
||||
#define _LIBCPP___ATOMIC_ATOMIC_REF_H
|
||||
|
||||
#include <__assert>
|
||||
#include <__atomic/atomic_sync.h>
|
||||
#include <__atomic/check_memory_order.h>
|
||||
#include <__atomic/to_gcc_order.h>
|
||||
#include <__concepts/arithmetic.h>
|
||||
#include <__concepts/same_as.h>
|
||||
#include <__config>
|
||||
#include <__memory/addressof.h>
|
||||
#include <__type_traits/has_unique_object_representation.h>
|
||||
#include <__type_traits/is_trivially_copyable.h>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
# pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#if _LIBCPP_STD_VER >= 20
|
||||
|
||||
template <class _Tp>
|
||||
struct __atomic_ref_base {
|
||||
protected:
|
||||
_Tp* __ptr_;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI __atomic_ref_base(_Tp& __obj) : __ptr_(std::addressof(__obj)) {}
|
||||
|
||||
private:
|
||||
_LIBCPP_HIDE_FROM_ABI static _Tp* __clear_padding(_Tp& __val) noexcept {
|
||||
_Tp* __ptr = std::addressof(__val);
|
||||
# if __has_builtin(__builtin_clear_padding)
|
||||
__builtin_clear_padding(__ptr);
|
||||
# endif
|
||||
return __ptr;
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI static bool __compare_exchange(
|
||||
_Tp* __ptr, _Tp* __expected, _Tp* __desired, bool __is_weak, int __success, int __failure) noexcept {
|
||||
if constexpr (
|
||||
# if __has_builtin(__builtin_clear_padding)
|
||||
has_unique_object_representations_v<_Tp> || floating_point<_Tp>
|
||||
# else
|
||||
true // NOLINT(readability-simplify-boolean-expr)
|
||||
# endif
|
||||
) {
|
||||
return __atomic_compare_exchange(__ptr, __expected, __desired, __is_weak, __success, __failure);
|
||||
} else { // _Tp has padding bits and __builtin_clear_padding is available
|
||||
__clear_padding(*__desired);
|
||||
_Tp __copy = *__expected;
|
||||
__clear_padding(__copy);
|
||||
// The algorithm we use here is basically to perform `__atomic_compare_exchange` on the
|
||||
// values until it has either succeeded, or failed because the value representation of the
|
||||
// objects involved was different. This is why we loop around __atomic_compare_exchange:
|
||||
// we basically loop until its failure is caused by the value representation of the objects
|
||||
// being different, not only their object representation.
|
||||
while (true) {
|
||||
_Tp __prev = __copy;
|
||||
if (__atomic_compare_exchange(__ptr, std::addressof(__copy), __desired, __is_weak, __success, __failure)) {
|
||||
return true;
|
||||
}
|
||||
_Tp __curr = __copy;
|
||||
if (std::memcmp(__clear_padding(__prev), __clear_padding(__curr), sizeof(_Tp)) != 0) {
|
||||
// Value representation without padding bits do not compare equal ->
|
||||
// write the current content of *ptr into *expected
|
||||
std::memcpy(__expected, std::addressof(__copy), sizeof(_Tp));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
friend struct __atomic_waitable_traits<__atomic_ref_base<_Tp>>;
|
||||
|
||||
public:
|
||||
using value_type = _Tp;
|
||||
|
||||
static constexpr size_t required_alignment = alignof(_Tp);
|
||||
|
||||
// The __atomic_always_lock_free builtin takes into account the alignment of the pointer if provided,
|
||||
// so we create a fake pointer with a suitable alignment when querying it. Note that we are guaranteed
|
||||
// that the pointer is going to be aligned properly at runtime because that is a (checked) precondition
|
||||
// of atomic_ref's constructor.
|
||||
static constexpr bool is_always_lock_free =
|
||||
__atomic_always_lock_free(sizeof(_Tp), reinterpret_cast<void*>(-required_alignment));
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_Tp), __ptr_); }
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI void store(_Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept
|
||||
_LIBCPP_CHECK_STORE_MEMORY_ORDER(__order) {
|
||||
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
||||
__order == memory_order::relaxed || __order == memory_order::release || __order == memory_order::seq_cst,
|
||||
"atomic_ref: memory order argument to atomic store operation is invalid");
|
||||
__atomic_store(__ptr_, __clear_padding(__desired), std::__to_gcc_order(__order));
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept {
|
||||
store(__desired);
|
||||
return __desired;
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __order = memory_order::seq_cst) const noexcept
|
||||
_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__order) {
|
||||
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
||||
__order == memory_order::relaxed || __order == memory_order::consume || __order == memory_order::acquire ||
|
||||
__order == memory_order::seq_cst,
|
||||
"atomic_ref: memory order argument to atomic load operation is invalid");
|
||||
alignas(_Tp) byte __mem[sizeof(_Tp)];
|
||||
auto* __ret = reinterpret_cast<_Tp*>(__mem);
|
||||
__atomic_load(__ptr_, __ret, std::__to_gcc_order(__order));
|
||||
return *__ret;
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI operator _Tp() const noexcept { return load(); }
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
|
||||
alignas(_Tp) byte __mem[sizeof(_Tp)];
|
||||
auto* __ret = reinterpret_cast<_Tp*>(__mem);
|
||||
__atomic_exchange(__ptr_, __clear_padding(__desired), __ret, std::__to_gcc_order(__order));
|
||||
return *__ret;
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI bool
|
||||
compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept
|
||||
_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__success, __failure) {
|
||||
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
||||
__failure == memory_order::relaxed || __failure == memory_order::consume ||
|
||||
__failure == memory_order::acquire || __failure == memory_order::seq_cst,
|
||||
"atomic_ref: failure memory order argument to weak atomic compare-and-exchange operation is invalid");
|
||||
return __compare_exchange(
|
||||
__ptr_,
|
||||
std::addressof(__expected),
|
||||
std::addressof(__desired),
|
||||
true,
|
||||
std::__to_gcc_order(__success),
|
||||
std::__to_gcc_order(__failure));
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI bool
|
||||
compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept
|
||||
_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__success, __failure) {
|
||||
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
||||
__failure == memory_order::relaxed || __failure == memory_order::consume ||
|
||||
__failure == memory_order::acquire || __failure == memory_order::seq_cst,
|
||||
"atomic_ref: failure memory order argument to strong atomic compare-and-exchange operation is invalid");
|
||||
return __compare_exchange(
|
||||
__ptr_,
|
||||
std::addressof(__expected),
|
||||
std::addressof(__desired),
|
||||
false,
|
||||
std::__to_gcc_order(__success),
|
||||
std::__to_gcc_order(__failure));
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI bool
|
||||
compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
|
||||
return __compare_exchange(
|
||||
__ptr_,
|
||||
std::addressof(__expected),
|
||||
std::addressof(__desired),
|
||||
true,
|
||||
std::__to_gcc_order(__order),
|
||||
std::__to_gcc_failure_order(__order));
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI bool
|
||||
compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
|
||||
return __compare_exchange(
|
||||
__ptr_,
|
||||
std::addressof(__expected),
|
||||
std::addressof(__desired),
|
||||
false,
|
||||
std::__to_gcc_order(__order),
|
||||
std::__to_gcc_failure_order(__order));
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI void wait(_Tp __old, memory_order __order = memory_order::seq_cst) const noexcept
|
||||
_LIBCPP_CHECK_WAIT_MEMORY_ORDER(__order) {
|
||||
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
||||
__order == memory_order::relaxed || __order == memory_order::consume || __order == memory_order::acquire ||
|
||||
__order == memory_order::seq_cst,
|
||||
"atomic_ref: memory order argument to atomic wait operation is invalid");
|
||||
std::__atomic_wait(*this, __old, __order);
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI void notify_one() const noexcept { std::__atomic_notify_one(*this); }
|
||||
_LIBCPP_HIDE_FROM_ABI void notify_all() const noexcept { std::__atomic_notify_all(*this); }
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct __atomic_waitable_traits<__atomic_ref_base<_Tp>> {
|
||||
static _LIBCPP_HIDE_FROM_ABI _Tp __atomic_load(const __atomic_ref_base<_Tp>& __a, memory_order __order) {
|
||||
return __a.load(__order);
|
||||
}
|
||||
static _LIBCPP_HIDE_FROM_ABI const _Tp* __atomic_contention_address(const __atomic_ref_base<_Tp>& __a) {
|
||||
return __a.__ptr_;
|
||||
}
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct atomic_ref : public __atomic_ref_base<_Tp> {
|
||||
static_assert(is_trivially_copyable_v<_Tp>, "std::atomic_ref<T> requires that 'T' be a trivially copyable type");
|
||||
|
||||
using __base = __atomic_ref_base<_Tp>;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
|
||||
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
||||
reinterpret_cast<uintptr_t>(std::addressof(__obj)) % __base::required_alignment == 0,
|
||||
"atomic_ref ctor: referenced object must be aligned to required_alignment");
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
|
||||
|
||||
atomic_ref& operator=(const atomic_ref&) = delete;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
requires(std::integral<_Tp> && !std::same_as<bool, _Tp>)
|
||||
struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
|
||||
using __base = __atomic_ref_base<_Tp>;
|
||||
|
||||
using difference_type = __base::value_type;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
|
||||
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
||||
reinterpret_cast<uintptr_t>(std::addressof(__obj)) % __base::required_alignment == 0,
|
||||
"atomic_ref ctor: referenced object must be aligned to required_alignment");
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
|
||||
|
||||
atomic_ref& operator=(const atomic_ref&) = delete;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
return __atomic_fetch_add(this->__ptr_, __arg, std::__to_gcc_order(__order));
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
return __atomic_fetch_sub(this->__ptr_, __arg, std::__to_gcc_order(__order));
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
return __atomic_fetch_and(this->__ptr_, __arg, std::__to_gcc_order(__order));
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
return __atomic_fetch_or(this->__ptr_, __arg, std::__to_gcc_order(__order));
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
return __atomic_fetch_xor(this->__ptr_, __arg, std::__to_gcc_order(__order));
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator++(int) const noexcept { return fetch_add(_Tp(1)); }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator--(int) const noexcept { return fetch_sub(_Tp(1)); }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator++() const noexcept { return fetch_add(_Tp(1)) + _Tp(1); }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator--() const noexcept { return fetch_sub(_Tp(1)) - _Tp(1); }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __arg) const noexcept { return fetch_add(__arg) + __arg; }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __arg) const noexcept { return fetch_sub(__arg) - __arg; }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator&=(_Tp __arg) const noexcept { return fetch_and(__arg) & __arg; }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator|=(_Tp __arg) const noexcept { return fetch_or(__arg) | __arg; }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator^=(_Tp __arg) const noexcept { return fetch_xor(__arg) ^ __arg; }
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
requires std::floating_point<_Tp>
|
||||
struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
|
||||
using __base = __atomic_ref_base<_Tp>;
|
||||
|
||||
using difference_type = __base::value_type;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
|
||||
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
||||
reinterpret_cast<uintptr_t>(std::addressof(__obj)) % __base::required_alignment == 0,
|
||||
"atomic_ref ctor: referenced object must be aligned to required_alignment");
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
|
||||
|
||||
atomic_ref& operator=(const atomic_ref&) = delete;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
_Tp __old = this->load(memory_order_relaxed);
|
||||
_Tp __new = __old + __arg;
|
||||
while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
|
||||
__new = __old + __arg;
|
||||
}
|
||||
return __old;
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
_Tp __old = this->load(memory_order_relaxed);
|
||||
_Tp __new = __old - __arg;
|
||||
while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
|
||||
__new = __old - __arg;
|
||||
}
|
||||
return __old;
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __arg) const noexcept { return fetch_add(__arg) + __arg; }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __arg) const noexcept { return fetch_sub(__arg) - __arg; }
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct atomic_ref<_Tp*> : public __atomic_ref_base<_Tp*> {
|
||||
using __base = __atomic_ref_base<_Tp*>;
|
||||
|
||||
using difference_type = ptrdiff_t;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp*& __ptr) : __base(__ptr) {}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* operator=(_Tp* __desired) const noexcept { return __base::operator=(__desired); }
|
||||
|
||||
atomic_ref& operator=(const atomic_ref&) = delete;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* fetch_add(ptrdiff_t __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
return __atomic_fetch_add(this->__ptr_, __arg * sizeof(_Tp), std::__to_gcc_order(__order));
|
||||
}
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* fetch_sub(ptrdiff_t __arg, memory_order __order = memory_order_seq_cst) const noexcept {
|
||||
return __atomic_fetch_sub(this->__ptr_, __arg * sizeof(_Tp), std::__to_gcc_order(__order));
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* operator++(int) const noexcept { return fetch_add(1); }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* operator--(int) const noexcept { return fetch_sub(1); }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* operator++() const noexcept { return fetch_add(1) + 1; }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* operator--() const noexcept { return fetch_sub(1) - 1; }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* operator+=(ptrdiff_t __arg) const noexcept { return fetch_add(__arg) + __arg; }
|
||||
_LIBCPP_HIDE_FROM_ABI _Tp* operator-=(ptrdiff_t __arg) const noexcept { return fetch_sub(__arg) - __arg; }
|
||||
};
|
||||
|
||||
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(atomic_ref);
|
||||
|
||||
#endif // _LIBCPP_STD_VER >= 20
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP__ATOMIC_ATOMIC_REF_H
|
||||
@@ -12,6 +12,7 @@
|
||||
#include <__atomic/contention_t.h>
|
||||
#include <__atomic/cxx_atomic_impl.h>
|
||||
#include <__atomic/memory_order.h>
|
||||
#include <__atomic/to_gcc_order.h>
|
||||
#include <__availability>
|
||||
#include <__chrono/duration.h>
|
||||
#include <__config>
|
||||
|
||||
@@ -27,4 +27,8 @@
|
||||
_LIBCPP_DIAGNOSE_WARNING(__f == memory_order_release || __f == memory_order_acq_rel, \
|
||||
"memory order argument to atomic operation is invalid")
|
||||
|
||||
#define _LIBCPP_CHECK_WAIT_MEMORY_ORDER(__m) \
|
||||
_LIBCPP_DIAGNOSE_WARNING(__m == memory_order_release || __m == memory_order_acq_rel, \
|
||||
"memory order argument to atomic operation is invalid")
|
||||
|
||||
#endif // _LIBCPP___ATOMIC_CHECK_MEMORY_ORDER_H
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
#define _LIBCPP___ATOMIC_CXX_ATOMIC_IMPL_H
|
||||
|
||||
#include <__atomic/memory_order.h>
|
||||
#include <__atomic/to_gcc_order.h>
|
||||
#include <__config>
|
||||
#include <__memory/addressof.h>
|
||||
#include <__type_traits/is_assignable.h>
|
||||
@@ -54,32 +55,6 @@ struct __cxx_atomic_base_impl {
|
||||
_Tp __a_value;
|
||||
};
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) {
|
||||
// Avoid switch statement to make this a constexpr.
|
||||
return __order == memory_order_relaxed
|
||||
? __ATOMIC_RELAXED
|
||||
: (__order == memory_order_acquire
|
||||
? __ATOMIC_ACQUIRE
|
||||
: (__order == memory_order_release
|
||||
? __ATOMIC_RELEASE
|
||||
: (__order == memory_order_seq_cst
|
||||
? __ATOMIC_SEQ_CST
|
||||
: (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL : __ATOMIC_CONSUME))));
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR int __to_gcc_failure_order(memory_order __order) {
|
||||
// Avoid switch statement to make this a constexpr.
|
||||
return __order == memory_order_relaxed
|
||||
? __ATOMIC_RELAXED
|
||||
: (__order == memory_order_acquire
|
||||
? __ATOMIC_ACQUIRE
|
||||
: (__order == memory_order_release
|
||||
? __ATOMIC_RELAXED
|
||||
: (__order == memory_order_seq_cst
|
||||
? __ATOMIC_SEQ_CST
|
||||
: (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE : __ATOMIC_CONSUME))));
|
||||
}
|
||||
|
||||
template <typename _Tp>
|
||||
_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_init(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __val) {
|
||||
__cxx_atomic_assign_volatile(__a->__a_value, __val);
|
||||
|
||||
54
libcxx/include/__atomic/to_gcc_order.h
Normal file
54
libcxx/include/__atomic/to_gcc_order.h
Normal file
@@ -0,0 +1,54 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___ATOMIC_TO_GCC_ORDER_H
|
||||
#define _LIBCPP___ATOMIC_TO_GCC_ORDER_H
|
||||
|
||||
#include <__atomic/memory_order.h>
|
||||
#include <__config>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
# pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#if defined(__ATOMIC_RELAXED) && defined(__ATOMIC_CONSUME) && defined(__ATOMIC_ACQUIRE) && \
|
||||
defined(__ATOMIC_RELEASE) && defined(__ATOMIC_ACQ_REL) && defined(__ATOMIC_SEQ_CST)
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) {
|
||||
// Avoid switch statement to make this a constexpr.
|
||||
return __order == memory_order_relaxed
|
||||
? __ATOMIC_RELAXED
|
||||
: (__order == memory_order_acquire
|
||||
? __ATOMIC_ACQUIRE
|
||||
: (__order == memory_order_release
|
||||
? __ATOMIC_RELEASE
|
||||
: (__order == memory_order_seq_cst
|
||||
? __ATOMIC_SEQ_CST
|
||||
: (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL : __ATOMIC_CONSUME))));
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR int __to_gcc_failure_order(memory_order __order) {
|
||||
// Avoid switch statement to make this a constexpr.
|
||||
return __order == memory_order_relaxed
|
||||
? __ATOMIC_RELAXED
|
||||
: (__order == memory_order_acquire
|
||||
? __ATOMIC_ACQUIRE
|
||||
: (__order == memory_order_release
|
||||
? __ATOMIC_RELAXED
|
||||
: (__order == memory_order_seq_cst
|
||||
? __ATOMIC_SEQ_CST
|
||||
: (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE : __ATOMIC_CONSUME))));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP___ATOMIC_TO_GCC_ORDER_H
|
||||
@@ -599,6 +599,7 @@ template <class T>
|
||||
#include <__atomic/atomic_flag.h>
|
||||
#include <__atomic/atomic_init.h>
|
||||
#include <__atomic/atomic_lock_free.h>
|
||||
#include <__atomic/atomic_ref.h>
|
||||
#include <__atomic/atomic_sync.h>
|
||||
#include <__atomic/check_memory_order.h>
|
||||
#include <__atomic/contention_t.h>
|
||||
|
||||
869
libcxx/include/libcxx.imp
Normal file
869
libcxx/include/libcxx.imp
Normal file
@@ -0,0 +1,869 @@
|
||||
[
|
||||
{ include: [ "<__algorithm/adjacent_find.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/all_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/any_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/binary_search.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/clamp.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/comp.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/comp_ref_type.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/copy_backward.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/copy_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/copy_move_common.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/copy_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/count.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/count_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/equal.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/equal_range.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/fill.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/fill_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/find.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/find_end.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/find_first_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/find_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/find_if_not.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/find_segment_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/fold.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/for_each.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/for_each_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/for_each_segment.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/generate.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/generate_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/half_positive.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/in_found_result.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/in_fun_result.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/in_in_out_result.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/in_in_result.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/in_out_out_result.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/in_out_result.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/includes.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/inplace_merge.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/is_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/is_heap_until.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/is_partitioned.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/is_permutation.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/is_sorted.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/is_sorted_until.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/iter_swap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/iterator_operations.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/lexicographical_compare.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/lexicographical_compare_three_way.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/lower_bound.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/make_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/make_projected.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/max.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/max_element.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/merge.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/min.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/min_element.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/min_max_result.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/minmax.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/minmax_element.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/mismatch.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/move.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/move_backward.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/next_permutation.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/none_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/nth_element.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/partial_sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/partial_sort_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/partition.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/partition_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/partition_point.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pop_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/prev_permutation.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_any_all_none_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backend.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backend.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/any_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/backend.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/fill.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/find_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/for_each.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/libdispatch.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/merge.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/serial.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/stable_sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/thread.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/transform.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_backends/cpu_backends/transform_reduce.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_count.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_equal.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_fill.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_find.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_for_each.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_frontend_dispatch.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_generate.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_is_partitioned.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_merge.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_move.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_replace.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_rotate_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_stable_sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/pstl_transform.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/push_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_adjacent_find.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_all_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_any_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_binary_search.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_clamp.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_contains.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_contains_subrange.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_copy_backward.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_copy_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_copy_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_count.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_count_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_ends_with.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_equal.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_equal_range.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_fill.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_fill_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_find.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_find_end.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_find_first_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_find_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_find_if_not.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_for_each.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_for_each_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_generate.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_generate_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_includes.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_inplace_merge.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_is_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_is_heap_until.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_is_partitioned.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_is_permutation.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_is_sorted.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_is_sorted_until.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_iterator_concept.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_lexicographical_compare.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_lower_bound.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_make_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_max.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_max_element.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_merge.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_min.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_min_element.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_minmax.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_minmax_element.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_mismatch.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_move.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_move_backward.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_next_permutation.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_none_of.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_nth_element.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_partial_sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_partial_sort_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_partition.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_partition_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_partition_point.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_pop_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_prev_permutation.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_push_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_remove.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_remove_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_remove_copy_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_remove_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_replace.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_replace_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_replace_copy_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_replace_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_reverse.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_reverse_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_rotate.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_rotate_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_sample.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_search.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_search_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_set_difference.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_set_intersection.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_set_symmetric_difference.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_set_union.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_shuffle.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_sort_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_stable_partition.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_stable_sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_starts_with.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_swap_ranges.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_transform.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_unique.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_unique_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/ranges_upper_bound.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/remove.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/remove_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/remove_copy_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/remove_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/replace.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/replace_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/replace_copy_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/replace_if.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/reverse.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/reverse_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/rotate.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/rotate_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/sample.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/search.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/search_n.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/set_difference.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/set_intersection.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/set_symmetric_difference.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/set_union.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/shift_left.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/shift_right.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/shuffle.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/sift_down.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/simd_utils.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/sort_heap.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/stable_partition.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/stable_sort.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/swap_ranges.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/three_way_comp_ref_type.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/transform.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/uniform_random_bit_generator_adaptor.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/unique.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/unique_copy.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/unwrap_iter.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/unwrap_range.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__algorithm/upper_bound.h>", "private", "<algorithm>", "public" ] },
|
||||
{ include: [ "<__atomic/aliases.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/atomic.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/atomic_base.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/atomic_flag.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/atomic_init.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/atomic_lock_free.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/atomic_ref.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/atomic_sync.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/check_memory_order.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/contention_t.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/cxx_atomic_impl.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/fence.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/is_always_lock_free.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/kill_dependency.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/memory_order.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__atomic/to_gcc_order.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__bit/bit_cast.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/bit_ceil.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/bit_floor.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/bit_log2.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/bit_width.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/blsr.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/byteswap.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/countl.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/countr.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/endian.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/has_single_bit.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/invert_if.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/popcount.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__bit/rotate.h>", "private", "<bit>", "public" ] },
|
||||
{ include: [ "<__charconv/chars_format.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/from_chars_integral.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/from_chars_result.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/tables.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/to_chars.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/to_chars_base_10.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/to_chars_floating_point.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/to_chars_integral.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/to_chars_result.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__charconv/traits.h>", "private", "<charconv>", "public" ] },
|
||||
{ include: [ "<__chrono/calendar.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/concepts.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/convert_to_timespec.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/convert_to_tm.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/day.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/duration.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/file_clock.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/formatter.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/hh_mm_ss.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/high_resolution_clock.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/leap_second.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/literals.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/month.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/month_weekday.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/monthday.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/ostream.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/parser_std_format_spec.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/statically_widen.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/steady_clock.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/sys_info.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/system_clock.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/time_point.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/time_zone.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/time_zone_link.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/tzdb.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/tzdb_list.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/weekday.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/year.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/year_month.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/year_month_day.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__chrono/year_month_weekday.h>", "private", "<chrono>", "public" ] },
|
||||
{ include: [ "<__compare/common_comparison_category.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/compare_partial_order_fallback.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/compare_strong_order_fallback.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/compare_three_way.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/compare_three_way_result.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/compare_weak_order_fallback.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/is_eq.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/ordering.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/partial_order.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/strong_order.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/synth_three_way.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/three_way_comparable.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__compare/weak_order.h>", "private", "<compare>", "public" ] },
|
||||
{ include: [ "<__concepts/arithmetic.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/assignable.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/boolean_testable.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/class_or_enum.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/common_reference_with.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/common_with.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/constructible.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/convertible_to.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/copyable.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/derived_from.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/destructible.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/different_from.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/equality_comparable.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/invocable.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/movable.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/predicate.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/regular.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/relation.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/same_as.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/semiregular.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/swappable.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__concepts/totally_ordered.h>", "private", "<concepts>", "public" ] },
|
||||
{ include: [ "<__condition_variable/condition_variable.h>", "private", "<condition_variable>", "public" ] },
|
||||
{ include: [ "<__coroutine/coroutine_handle.h>", "private", "<coroutine>", "public" ] },
|
||||
{ include: [ "<__coroutine/coroutine_traits.h>", "private", "<coroutine>", "public" ] },
|
||||
{ include: [ "<__coroutine/noop_coroutine_handle.h>", "private", "<coroutine>", "public" ] },
|
||||
{ include: [ "<__coroutine/trivial_awaitables.h>", "private", "<coroutine>", "public" ] },
|
||||
{ include: [ "<__exception/exception.h>", "private", "<exception>", "public" ] },
|
||||
{ include: [ "<__exception/exception_ptr.h>", "private", "<exception>", "public" ] },
|
||||
{ include: [ "<__exception/nested_exception.h>", "private", "<exception>", "public" ] },
|
||||
{ include: [ "<__exception/operations.h>", "private", "<exception>", "public" ] },
|
||||
{ include: [ "<__exception/terminate.h>", "private", "<exception>", "public" ] },
|
||||
{ include: [ "<__expected/bad_expected_access.h>", "private", "<expected>", "public" ] },
|
||||
{ include: [ "<__expected/expected.h>", "private", "<expected>", "public" ] },
|
||||
{ include: [ "<__expected/unexpect.h>", "private", "<expected>", "public" ] },
|
||||
{ include: [ "<__expected/unexpected.h>", "private", "<expected>", "public" ] },
|
||||
{ include: [ "<__filesystem/copy_options.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/directory_entry.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/directory_iterator.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/directory_options.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/file_status.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/file_time_type.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/file_type.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/filesystem_error.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/operations.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/path.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/path_iterator.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/perm_options.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/perms.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/recursive_directory_iterator.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/space_info.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__filesystem/u8path.h>", "private", "<filesystem>", "public" ] },
|
||||
{ include: [ "<__format/buffer.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/concepts.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/container_adaptor.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/enable_insertable.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/escaped_output_table.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/extended_grapheme_cluster_table.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_arg.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_arg_store.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_args.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_context.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_error.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_functions.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_parse_context.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_string.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/format_to_n_result.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_bool.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_char.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_floating_point.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_integer.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_integral.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_output.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_pointer.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_string.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/formatter_tuple.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/indic_conjunct_break_table.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/parser_std_format_spec.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/range_default_formatter.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/range_formatter.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/unicode.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/width_estimation_table.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__format/write_escaped.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__functional/binary_function.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/binary_negate.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/bind.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/bind_back.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/bind_front.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/binder1st.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/binder2nd.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/boyer_moore_searcher.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/compose.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/default_searcher.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/function.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/hash.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/identity.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/invoke.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/is_transparent.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/mem_fn.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/mem_fun_ref.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/not_fn.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/operations.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/perfect_forward.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/pointer_to_binary_function.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/pointer_to_unary_function.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/ranges_operations.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/reference_wrapper.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/unary_function.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/unary_negate.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__functional/weak_result_type.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__fwd/array.h>", "private", "<array>", "public" ] },
|
||||
{ include: [ "<__fwd/bit_reference.h>", "private", "<bitset>", "public" ] },
|
||||
{ include: [ "<__fwd/bit_reference.h>", "private", "<vector>", "public" ] },
|
||||
{ include: [ "<__fwd/complex.h>", "private", "<complex>", "public" ] },
|
||||
{ include: [ "<__fwd/deque.h>", "private", "<deque>", "public" ] },
|
||||
{ include: [ "<__fwd/format.h>", "private", "<format>", "public" ] },
|
||||
{ include: [ "<__fwd/fstream.h>", "private", "<iosfwd>", "public" ] },
|
||||
{ include: [ "<__fwd/functional.h>", "private", "<functional>", "public" ] },
|
||||
{ include: [ "<__fwd/ios.h>", "private", "<iosfwd>", "public" ] },
|
||||
{ include: [ "<__fwd/istream.h>", "private", "<iosfwd>", "public" ] },
|
||||
{ include: [ "<__fwd/mdspan.h>", "private", "<mdspan>", "public" ] },
|
||||
{ include: [ "<__fwd/memory.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__fwd/memory_resource.h>", "private", "<memory_resource>", "public" ] },
|
||||
{ include: [ "<__fwd/ostream.h>", "private", "<iosfwd>", "public" ] },
|
||||
{ include: [ "<__fwd/pair.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__fwd/queue.h>", "private", "<queue>", "public" ] },
|
||||
{ include: [ "<__fwd/span.h>", "private", "<span>", "public" ] },
|
||||
{ include: [ "<__fwd/sstream.h>", "private", "<iosfwd>", "public" ] },
|
||||
{ include: [ "<__fwd/stack.h>", "private", "<stack>", "public" ] },
|
||||
{ include: [ "<__fwd/streambuf.h>", "private", "<iosfwd>", "public" ] },
|
||||
{ include: [ "<__fwd/string.h>", "private", "<string>", "public" ] },
|
||||
{ include: [ "<__fwd/string_view.h>", "private", "<string_view>", "public" ] },
|
||||
{ include: [ "<__fwd/subrange.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__fwd/tuple.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__fwd/vector.h>", "private", "<vector>", "public" ] },
|
||||
{ include: [ "<__ios/fpos.h>", "private", "<ios>", "public" ] },
|
||||
{ include: [ "<__iterator/access.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/advance.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/back_insert_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/bounded_iter.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/common_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/concepts.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/counted_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/cpp17_iterator_concepts.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/data.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/default_sentinel.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/distance.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/empty.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/erase_if_container.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/front_insert_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/incrementable_traits.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/indirectly_comparable.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/insert_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/istream_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/istreambuf_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/iter_move.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/iter_swap.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/iterator_traits.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/iterator_with_data.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/mergeable.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/move_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/move_sentinel.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/next.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/ostream_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/ostreambuf_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/permutable.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/prev.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/projected.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/ranges_iterator_traits.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/readable_traits.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/reverse_access.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/reverse_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/segmented_iterator.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/size.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/sortable.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/unreachable_sentinel.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__iterator/wrap_iter.h>", "private", "<iterator>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/android.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/bsd_locale_defaults.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/bsd_locale_fallbacks.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/fuchsia.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/ibm.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/locale_guard.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/musl.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/newlib.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/openbsd.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__locale_dir/locale_base_api/win32.h>", "private", "<locale>", "public" ] },
|
||||
{ include: [ "<__math/abs.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/copysign.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/error_functions.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/exponential_functions.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/fdim.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/fma.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/gamma.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/hyperbolic_functions.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/hypot.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/inverse_hyperbolic_functions.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/inverse_trigonometric_functions.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/logarithms.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/min_max.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/modulo.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/remainder.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/roots.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/rounding_functions.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/traits.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__math/trigonometric_functions.h>", "private", "<cmath>", "public" ] },
|
||||
{ include: [ "<__mdspan/default_accessor.h>", "private", "<mdspan>", "public" ] },
|
||||
{ include: [ "<__mdspan/extents.h>", "private", "<mdspan>", "public" ] },
|
||||
{ include: [ "<__mdspan/layout_left.h>", "private", "<mdspan>", "public" ] },
|
||||
{ include: [ "<__mdspan/layout_right.h>", "private", "<mdspan>", "public" ] },
|
||||
{ include: [ "<__mdspan/layout_stride.h>", "private", "<mdspan>", "public" ] },
|
||||
{ include: [ "<__mdspan/mdspan.h>", "private", "<mdspan>", "public" ] },
|
||||
{ include: [ "<__memory/addressof.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/align.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/aligned_alloc.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/allocate_at_least.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/allocation_guard.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/allocator.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/allocator_arg_t.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/allocator_destructor.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/allocator_traits.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/assume_aligned.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/auto_ptr.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/builtin_new_allocator.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/compressed_pair.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/concepts.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/construct_at.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/destruct_n.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/pointer_traits.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/ranges_construct_at.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/ranges_uninitialized_algorithms.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/raw_storage_iterator.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/shared_ptr.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/swap_allocator.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/temp_value.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/temporary_buffer.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/uninitialized_algorithms.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/unique_ptr.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/uses_allocator.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/uses_allocator_construction.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory/voidify.h>", "private", "<memory>", "public" ] },
|
||||
{ include: [ "<__memory_resource/memory_resource.h>", "private", "<memory_resource>", "public" ] },
|
||||
{ include: [ "<__memory_resource/monotonic_buffer_resource.h>", "private", "<memory_resource>", "public" ] },
|
||||
{ include: [ "<__memory_resource/polymorphic_allocator.h>", "private", "<memory_resource>", "public" ] },
|
||||
{ include: [ "<__memory_resource/pool_options.h>", "private", "<memory_resource>", "public" ] },
|
||||
{ include: [ "<__memory_resource/synchronized_pool_resource.h>", "private", "<memory_resource>", "public" ] },
|
||||
{ include: [ "<__memory_resource/unsynchronized_pool_resource.h>", "private", "<memory_resource>", "public" ] },
|
||||
{ include: [ "<__mutex/lock_guard.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__mutex/mutex.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__mutex/once_flag.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__mutex/tag_types.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__mutex/unique_lock.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__numeric/accumulate.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/adjacent_difference.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/exclusive_scan.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/gcd_lcm.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/inclusive_scan.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/inner_product.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/iota.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/midpoint.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/partial_sum.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/pstl_reduce.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/pstl_transform_reduce.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/reduce.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/saturation_arithmetic.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/transform_exclusive_scan.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/transform_inclusive_scan.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__numeric/transform_reduce.h>", "private", "<numeric>", "public" ] },
|
||||
{ include: [ "<__random/bernoulli_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/binomial_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/cauchy_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/chi_squared_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/clamp_to_integral.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/default_random_engine.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/discard_block_engine.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/discrete_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/exponential_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/extreme_value_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/fisher_f_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/gamma_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/generate_canonical.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/geometric_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/independent_bits_engine.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/is_seed_sequence.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/is_valid.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/knuth_b.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/linear_congruential_engine.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/log2.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/lognormal_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/mersenne_twister_engine.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/negative_binomial_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/normal_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/piecewise_constant_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/piecewise_linear_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/poisson_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/random_device.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/ranlux.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/seed_seq.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/shuffle_order_engine.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/student_t_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/subtract_with_carry_engine.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/uniform_int_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/uniform_random_bit_generator.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/uniform_real_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__random/weibull_distribution.h>", "private", "<random>", "public" ] },
|
||||
{ include: [ "<__ranges/access.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/all.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/as_rvalue_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/chunk_by_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/common_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/concepts.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/container_compatible_range.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/counted.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/dangling.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/data.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/drop_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/drop_while_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/elements_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/empty.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/empty_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/enable_borrowed_range.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/enable_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/filter_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/from_range.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/iota_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/istream_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/join_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/lazy_split_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/movable_box.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/non_propagating_cache.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/owning_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/range_adaptor.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/rbegin.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/ref_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/rend.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/repeat_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/reverse_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/single_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/size.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/split_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/subrange.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/take_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/take_while_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/to.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/transform_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/view_interface.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/views.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__ranges/zip_view.h>", "private", "<ranges>", "public" ] },
|
||||
{ include: [ "<__stop_token/atomic_unique_lock.h>", "private", "<stop_token>", "public" ] },
|
||||
{ include: [ "<__stop_token/intrusive_list_view.h>", "private", "<stop_token>", "public" ] },
|
||||
{ include: [ "<__stop_token/intrusive_shared_ptr.h>", "private", "<stop_token>", "public" ] },
|
||||
{ include: [ "<__stop_token/stop_callback.h>", "private", "<stop_token>", "public" ] },
|
||||
{ include: [ "<__stop_token/stop_source.h>", "private", "<stop_token>", "public" ] },
|
||||
{ include: [ "<__stop_token/stop_state.h>", "private", "<stop_token>", "public" ] },
|
||||
{ include: [ "<__stop_token/stop_token.h>", "private", "<stop_token>", "public" ] },
|
||||
{ include: [ "<__string/char_traits.h>", "private", "<string>", "public" ] },
|
||||
{ include: [ "<__string/constexpr_c_functions.h>", "private", "<string>", "public" ] },
|
||||
{ include: [ "<__string/extern_template_lists.h>", "private", "<string>", "public" ] },
|
||||
{ include: [ "<__system_error/errc.h>", "private", "<system_error>", "public" ] },
|
||||
{ include: [ "<__system_error/error_category.h>", "private", "<system_error>", "public" ] },
|
||||
{ include: [ "<__system_error/error_code.h>", "private", "<system_error>", "public" ] },
|
||||
{ include: [ "<__system_error/error_condition.h>", "private", "<system_error>", "public" ] },
|
||||
{ include: [ "<__system_error/system_error.h>", "private", "<system_error>", "public" ] },
|
||||
{ include: [ "<__thread/formatter.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/id.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/jthread.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/poll_with_backoff.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/support.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__thread/support.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__thread/support.h>", "private", "<semaphore>", "public" ] },
|
||||
{ include: [ "<__thread/support.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/support/c11.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__thread/support/c11.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__thread/support/c11.h>", "private", "<semaphore>", "public" ] },
|
||||
{ include: [ "<__thread/support/c11.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/support/external.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__thread/support/external.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__thread/support/external.h>", "private", "<semaphore>", "public" ] },
|
||||
{ include: [ "<__thread/support/external.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/support/pthread.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__thread/support/pthread.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__thread/support/pthread.h>", "private", "<semaphore>", "public" ] },
|
||||
{ include: [ "<__thread/support/pthread.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/support/windows.h>", "private", "<atomic>", "public" ] },
|
||||
{ include: [ "<__thread/support/windows.h>", "private", "<mutex>", "public" ] },
|
||||
{ include: [ "<__thread/support/windows.h>", "private", "<semaphore>", "public" ] },
|
||||
{ include: [ "<__thread/support/windows.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/this_thread.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/thread.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__thread/timed_backoff_policy.h>", "private", "<thread>", "public" ] },
|
||||
{ include: [ "<__tuple/find_index.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/make_tuple_types.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/sfinae_helpers.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/tuple_element.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/tuple_indices.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/tuple_like.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/tuple_like_ext.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/tuple_like_no_subrange.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/tuple_size.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__tuple/tuple_types.h>", "private", "<tuple>", "public" ] },
|
||||
{ include: [ "<__type_traits/add_const.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/add_cv.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/add_lvalue_reference.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/add_pointer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/add_rvalue_reference.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/add_volatile.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/aligned_storage.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/aligned_union.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/alignment_of.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/apply_cv.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/can_extract_key.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/common_reference.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/common_type.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/conditional.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/conjunction.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/copy_cv.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/copy_cvref.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/datasizeof.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/decay.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/dependent_type.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/desugars_to.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/disjunction.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/enable_if.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/extent.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/has_unique_object_representation.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/has_virtual_destructor.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/integral_constant.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/invoke.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_abstract.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_aggregate.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_allocator.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_always_bitcastable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_arithmetic.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_array.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_assignable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_base_of.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_bounded_array.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_callable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_char_like_type.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_class.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_compound.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_const.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_constant_evaluated.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_constructible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_convertible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_core_convertible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_destructible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_empty.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_enum.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_equality_comparable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_execution_policy.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_final.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_floating_point.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_function.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_fundamental.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_implicitly_default_constructible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_integral.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_literal_type.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_member_function_pointer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_member_object_pointer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_member_pointer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_nothrow_assignable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_nothrow_constructible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_nothrow_convertible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_nothrow_destructible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_null_pointer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_object.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_pod.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_pointer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_polymorphic.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_primary_template.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_reference.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_reference_wrapper.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_referenceable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_same.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_scalar.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_scoped_enum.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_signed.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_signed_integer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_specialization.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_standard_layout.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_swappable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_trivial.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_trivially_assignable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_trivially_constructible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_trivially_copyable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_trivially_destructible.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_trivially_lexicographically_comparable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_trivially_relocatable.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_unbounded_array.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_union.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_unsigned.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_unsigned_integer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_valid_expansion.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_void.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/is_volatile.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/lazy.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/make_32_64_or_128_bit.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/make_const_lvalue_ref.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/make_signed.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/make_unsigned.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/maybe_const.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/nat.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/negation.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/noexcept_move_assign_container.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/promote.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/rank.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_all_extents.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_const.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_const_ref.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_cv.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_cvref.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_extent.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_pointer.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_reference.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/remove_volatile.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/result_of.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/strip_signature.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/type_identity.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/type_list.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/underlying_type.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/unwrap_ref.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__type_traits/void_t.h>", "private", "<type_traits>", "public" ] },
|
||||
{ include: [ "<__utility/as_const.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/as_lvalue.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/auto_cast.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/cmp.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/convert_to_integral.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/declval.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/empty.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/exception_guard.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/exchange.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/forward.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/forward_like.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/in_place.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/integer_sequence.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/is_pointer_in_range.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/move.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/no_destroy.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/pair.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/piecewise_construct.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/priority_tag.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/rel_ops.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/small_buffer.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/swap.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/to_underlying.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__utility/unreachable.h>", "private", "<utility>", "public" ] },
|
||||
{ include: [ "<__variant/monostate.h>", "private", "<variant>", "public" ] },
|
||||
]
|
||||
@@ -1066,7 +1066,11 @@ module std_private_atomic_atomic_flag [system] {
|
||||
}
|
||||
module std_private_atomic_atomic_init [system] { header "__atomic/atomic_init.h" }
|
||||
module std_private_atomic_atomic_lock_free [system] { header "__atomic/atomic_lock_free.h" }
|
||||
module std_private_atomic_atomic_sync [system] { header "__atomic/atomic_sync.h" }
|
||||
module std_private_atomic_atomic_ref [system] { header "__atomic/atomic_ref.h" }
|
||||
module std_private_atomic_atomic_sync [system] {
|
||||
header "__atomic/atomic_sync.h"
|
||||
export std_private_atomic_to_gcc_order
|
||||
}
|
||||
module std_private_atomic_check_memory_order [system] { header "__atomic/check_memory_order.h" }
|
||||
module std_private_atomic_contention_t [system] { header "__atomic/contention_t.h" }
|
||||
module std_private_atomic_cxx_atomic_impl [system] { header "__atomic/cxx_atomic_impl.h" }
|
||||
@@ -1074,6 +1078,10 @@ module std_private_atomic_fence [system] { header "__atomic/fence.
|
||||
module std_private_atomic_is_always_lock_free [system] { header "__atomic/is_always_lock_free.h" }
|
||||
module std_private_atomic_kill_dependency [system] { header "__atomic/kill_dependency.h" }
|
||||
module std_private_atomic_memory_order [system] { header "__atomic/memory_order.h" }
|
||||
module std_private_atomic_to_gcc_order [system] {
|
||||
header "__atomic/to_gcc_order.h"
|
||||
export std_private_atomic_memory_order
|
||||
}
|
||||
|
||||
module std_private_bit_bit_cast [system] { header "__bit/bit_cast.h" }
|
||||
module std_private_bit_bit_ceil [system] { header "__bit/bit_ceil.h" }
|
||||
|
||||
@@ -22,7 +22,7 @@ export namespace std {
|
||||
|
||||
// [atomics.ref.generic], class template atomic_ref
|
||||
// [atomics.ref.pointer], partial specialization for pointers
|
||||
// using std::atomic_ref _LIBCPP_USING_IF_EXISTS;
|
||||
using std::atomic_ref _LIBCPP_USING_IF_EXISTS;
|
||||
|
||||
// [atomics.types.generic], class template atomic
|
||||
using std::atomic _LIBCPP_USING_IF_EXISTS;
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: has-unix-headers
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: libcpp-hardening-mode=none || libcpp-hardening-mode=fast
|
||||
// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
|
||||
// ADDITIONAL_COMPILE_FLAGS: -Wno-user-defined-warnings
|
||||
|
||||
// <atomic>
|
||||
|
||||
// bool compare_exchange_strong(T& expected, T desired, memory_order success, memory_order failure) const noexcept;
|
||||
//
|
||||
// Preconditions: failure is memory_order::relaxed, memory_order::consume, memory_order::acquire, or memory_order::seq_cst.
|
||||
|
||||
#include <atomic>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "check_assertion.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestCompareExchangeStrongInvalidMemoryOrder {
|
||||
void operator()() const {
|
||||
{ // no assertion should trigger here
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
T t(T(2));
|
||||
a.compare_exchange_strong(t, T(3), std::memory_order_relaxed, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
T t(T(2));
|
||||
a.compare_exchange_strong(t, T(3), std::memory_order_relaxed, std::memory_order_release);
|
||||
}()),
|
||||
"atomic_ref: failure memory order argument to strong atomic compare-and-exchange operation is invalid");
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
T t(T(2));
|
||||
a.compare_exchange_strong(t, T(3), std::memory_order_relaxed, std::memory_order_acq_rel);
|
||||
}()),
|
||||
"atomic_ref: failure memory order argument to strong atomic compare-and-exchange operation is invalid");
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestCompareExchangeStrongInvalidMemoryOrder>()();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: has-unix-headers
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: libcpp-hardening-mode=none || libcpp-hardening-mode=fast
|
||||
// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
|
||||
// ADDITIONAL_COMPILE_FLAGS: -Wno-user-defined-warnings
|
||||
|
||||
// <atomic>
|
||||
|
||||
// bool compare_exchange_weak(T& expected, T desired, memory_order success, memory_order failure) const noexcept;
|
||||
//
|
||||
// Preconditions: failure is memory_order::relaxed, memory_order::consume, memory_order::acquire, or memory_order::seq_cst.
|
||||
|
||||
#include <atomic>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "check_assertion.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestCompareExchangeWeakInvalidMemoryOrder {
|
||||
void operator()() const {
|
||||
{ // no assertion should trigger here
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
T t(T(2));
|
||||
a.compare_exchange_weak(t, T(3), std::memory_order_relaxed, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
T t(T(2));
|
||||
a.compare_exchange_weak(t, T(3), std::memory_order_relaxed, std::memory_order_release);
|
||||
}()),
|
||||
"atomic_ref: failure memory order argument to weak atomic compare-and-exchange operation is invalid");
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
T t(T(2));
|
||||
a.compare_exchange_weak(t, T(3), std::memory_order_relaxed, std::memory_order_acq_rel);
|
||||
}()),
|
||||
"atomic_ref: failure memory order argument to weak atomic compare-and-exchange operation is invalid");
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestCompareExchangeWeakInvalidMemoryOrder>()();
|
||||
return 0;
|
||||
}
|
||||
40
libcxx/test/libcxx/atomics/atomics.ref/assert.ctor.pass.cpp
Normal file
40
libcxx/test/libcxx/atomics/atomics.ref/assert.ctor.pass.cpp
Normal file
@@ -0,0 +1,40 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: has-unix-headers
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: libcpp-hardening-mode=none || libcpp-hardening-mode=fast
|
||||
// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
|
||||
|
||||
// <atomic>
|
||||
|
||||
// atomic_ref(T& obj);
|
||||
//
|
||||
// Preconditions: The referenced object is aligned to required_alignment.
|
||||
|
||||
#include <atomic>
|
||||
#include <cstddef>
|
||||
|
||||
#include "check_assertion.h"
|
||||
|
||||
int main(int, char**) {
|
||||
{ // no assertion should trigger here
|
||||
alignas(float) std::byte c[sizeof(float)];
|
||||
float* f = new (c) float(3.14f);
|
||||
[[maybe_unused]] std::atomic_ref<float> r(*f);
|
||||
}
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
alignas(float) std::byte c[2 * sizeof(float)]; // intentionally larger
|
||||
float* f = new (c + 1) float(3.14f); // intentionally misaligned
|
||||
[[maybe_unused]] std::atomic_ref<float> r(*f);
|
||||
}()),
|
||||
"atomic_ref ctor: referenced object must be aligned to required_alignment");
|
||||
|
||||
return 0;
|
||||
}
|
||||
55
libcxx/test/libcxx/atomics/atomics.ref/assert.load.pass.cpp
Normal file
55
libcxx/test/libcxx/atomics/atomics.ref/assert.load.pass.cpp
Normal file
@@ -0,0 +1,55 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: has-unix-headers
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: libcpp-hardening-mode=none || libcpp-hardening-mode=fast
|
||||
// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
|
||||
// ADDITIONAL_COMPILE_FLAGS: -Wno-user-defined-warnings
|
||||
|
||||
// <atomic>
|
||||
|
||||
// T load(memory_order order = memory_order::seq_cst) const noexcept;
|
||||
//
|
||||
// Preconditions: order is memory_order::relaxed, memory_order::consume, memory_order::acquire, or memory_order::seq_cst.
|
||||
|
||||
#include <atomic>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "check_assertion.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestLoadInvalidMemoryOrder {
|
||||
void operator()() const {
|
||||
{ // no assertion should trigger here
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
(void)a.load(std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
(void)a.load(std::memory_order_release);
|
||||
}()),
|
||||
"atomic_ref: memory order argument to atomic load operation is invalid");
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
(void)a.load(std::memory_order_acq_rel);
|
||||
}()),
|
||||
"atomic_ref: memory order argument to atomic load operation is invalid");
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestLoadInvalidMemoryOrder>()();
|
||||
return 0;
|
||||
}
|
||||
63
libcxx/test/libcxx/atomics/atomics.ref/assert.store.pass.cpp
Normal file
63
libcxx/test/libcxx/atomics/atomics.ref/assert.store.pass.cpp
Normal file
@@ -0,0 +1,63 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: has-unix-headers
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: libcpp-hardening-mode=none || libcpp-hardening-mode=fast
|
||||
// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
|
||||
// ADDITIONAL_COMPILE_FLAGS: -Wno-user-defined-warnings
|
||||
|
||||
// <atomic>
|
||||
|
||||
// void store(T desired, memory_order order = memory_order::seq_cst) const noexcept;
|
||||
//
|
||||
// Preconditions: order is memory_order::relaxed, memory_order::release, or memory_order::seq_cst.
|
||||
|
||||
#include <atomic>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "check_assertion.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestStoreInvalidMemoryOrder {
|
||||
void operator()() const {
|
||||
{ // no assertion should trigger here
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
a.store(T(2), std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
a.store(T(2), std::memory_order_consume);
|
||||
}()),
|
||||
"atomic_ref: memory order argument to atomic store operation is invalid");
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
a.store(T(2), std::memory_order_acquire);
|
||||
}()),
|
||||
"atomic_ref: memory order argument to atomic store operation is invalid");
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
a.store(T(2), std::memory_order_acq_rel);
|
||||
}()),
|
||||
"atomic_ref: memory order argument to atomic store operation is invalid");
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestStoreInvalidMemoryOrder>()();
|
||||
return 0;
|
||||
}
|
||||
55
libcxx/test/libcxx/atomics/atomics.ref/assert.wait.pass.cpp
Normal file
55
libcxx/test/libcxx/atomics/atomics.ref/assert.wait.pass.cpp
Normal file
@@ -0,0 +1,55 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// REQUIRES: has-unix-headers
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: libcpp-hardening-mode=none || libcpp-hardening-mode=fast
|
||||
// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
|
||||
// ADDITIONAL_COMPILE_FLAGS: -Wno-user-defined-warnings
|
||||
|
||||
// <atomic>
|
||||
|
||||
// void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
|
||||
//
|
||||
// Preconditions: order is memory_order::relaxed, memory_order::consume, memory_order::acquire, or memory_order::seq_cst.
|
||||
|
||||
#include <atomic>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "check_assertion.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestWaitInvalidMemoryOrder {
|
||||
void operator()() const {
|
||||
{ // no assertion should trigger here
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
a.wait(T(2), std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
a.wait(T(2), std::memory_order_release);
|
||||
}()),
|
||||
"atomic_ref: memory order argument to atomic wait operation is invalid");
|
||||
|
||||
TEST_LIBCPP_ASSERT_FAILURE(
|
||||
([] {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
a.wait(T(2), std::memory_order_acq_rel);
|
||||
}()),
|
||||
"atomic_ref: memory order argument to atomic wait operation is invalid");
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestWaitInvalidMemoryOrder>()();
|
||||
return 0;
|
||||
}
|
||||
50
libcxx/test/std/atomics/atomics.ref/assign.pass.cpp
Normal file
50
libcxx/test/std/atomics/atomics.ref/assign.pass.cpp
Normal file
@@ -0,0 +1,50 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// T operator=(T) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestAssign {
|
||||
void operator()() const {
|
||||
{
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
std::same_as<T> decltype(auto) y = (a = T(2));
|
||||
assert(y == T(2));
|
||||
assert(x == T(2));
|
||||
|
||||
ASSERT_NOEXCEPT(a = T(0));
|
||||
static_assert(std::is_nothrow_assignable_v<std::atomic_ref<T>, T>);
|
||||
|
||||
static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
|
||||
}
|
||||
|
||||
{
|
||||
auto assign = [](std::atomic_ref<T> const& y, T, T new_val) { y = new_val; };
|
||||
auto load = [](std::atomic_ref<T> const& y) { return y.load(); };
|
||||
test_seq_cst<T>(assign, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestAssign>()();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type operator&=(integral-type) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_bitwise_and_assign = requires { std::declval<T const>() &= std::declval<T>(); };
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveBitwiseAndAssign {
|
||||
void operator()() const { static_assert(!has_bitwise_and_assign<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestBitwiseAndAssign {
|
||||
void operator()() const {
|
||||
static_assert(std::is_integral_v<T>);
|
||||
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
std::same_as<T> decltype(auto) y = (a &= T(1));
|
||||
assert(y == T(1));
|
||||
assert(x == T(1));
|
||||
ASSERT_NOEXCEPT(a &= T(0));
|
||||
|
||||
y = (a &= T(2));
|
||||
assert(y == T(0));
|
||||
assert(x == T(0));
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestBitwiseAndAssign>()();
|
||||
|
||||
TestEachFloatingPointType<TestDoesNotHaveBitwiseAndAssign>()();
|
||||
|
||||
TestEachPointerType<TestDoesNotHaveBitwiseAndAssign>()();
|
||||
|
||||
TestDoesNotHaveBitwiseAndAssign<bool>()();
|
||||
TestDoesNotHaveBitwiseAndAssign<UserAtomicType>()();
|
||||
TestDoesNotHaveBitwiseAndAssign<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type operator|=(integral-type) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_bitwise_or_assign = requires { std::declval<T const>() |= std::declval<T>(); };
|
||||
|
||||
template < typename T>
|
||||
struct TestDoesNotHaveBitwiseOrAssign {
|
||||
void operator()() const { static_assert(!has_bitwise_or_assign<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestBitwiseOrAssign {
|
||||
void operator()() const {
|
||||
static_assert(std::is_integral_v<T>);
|
||||
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
std::same_as<T> decltype(auto) y = (a |= T(2));
|
||||
assert(y == T(3));
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a |= T(0));
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestBitwiseOrAssign>()();
|
||||
|
||||
TestEachFloatingPointType<TestDoesNotHaveBitwiseOrAssign>()();
|
||||
|
||||
TestEachPointerType<TestDoesNotHaveBitwiseOrAssign>()();
|
||||
|
||||
TestDoesNotHaveBitwiseOrAssign<bool>()();
|
||||
TestDoesNotHaveBitwiseOrAssign<UserAtomicType>()();
|
||||
TestDoesNotHaveBitwiseOrAssign<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type operator|=(integral-type) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_bitwise_xor_assign = requires { std::declval<T const>() ^= std::declval<T>(); };
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveBitwiseXorAssign {
|
||||
void operator()() const { static_assert(!has_bitwise_xor_assign<std::atomic_ref<float>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestBitwiseXorAssign {
|
||||
void operator()() const {
|
||||
static_assert(std::is_integral_v<T>);
|
||||
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
std::same_as<T> decltype(auto) y = (a ^= T(2));
|
||||
assert(y == T(3));
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a ^= T(0));
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestBitwiseXorAssign>()();
|
||||
|
||||
TestEachFloatingPointType<TestDoesNotHaveBitwiseXorAssign>()();
|
||||
|
||||
TestEachPointerType<TestDoesNotHaveBitwiseXorAssign>()();
|
||||
|
||||
TestDoesNotHaveBitwiseXorAssign<bool>()();
|
||||
TestDoesNotHaveBitwiseXorAssign<UserAtomicType>()();
|
||||
TestDoesNotHaveBitwiseXorAssign<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,221 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// bool compare_exchange_strong(T&, T, memory_order, memory_order) const noexcept;
|
||||
// bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestCompareExchangeStrong {
|
||||
void operator()() const {
|
||||
{
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
T t(T(1));
|
||||
std::same_as<bool> decltype(auto) y = a.compare_exchange_strong(t, T(2));
|
||||
assert(y == true);
|
||||
assert(a == T(2));
|
||||
assert(t == T(1));
|
||||
y = a.compare_exchange_strong(t, T(3));
|
||||
assert(y == false);
|
||||
assert(a == T(2));
|
||||
assert(t == T(2));
|
||||
|
||||
ASSERT_NOEXCEPT(a.compare_exchange_strong(t, T(2)));
|
||||
}
|
||||
{
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
T t(T(1));
|
||||
std::same_as<bool> decltype(auto) y = a.compare_exchange_strong(t, T(2), std::memory_order_seq_cst);
|
||||
assert(y == true);
|
||||
assert(a == T(2));
|
||||
assert(t == T(1));
|
||||
y = a.compare_exchange_strong(t, T(3), std::memory_order_seq_cst);
|
||||
assert(y == false);
|
||||
assert(a == T(2));
|
||||
assert(t == T(2));
|
||||
|
||||
ASSERT_NOEXCEPT(a.compare_exchange_strong(t, T(2), std::memory_order_seq_cst));
|
||||
}
|
||||
{
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
T t(T(1));
|
||||
std::same_as<bool> decltype(auto) y =
|
||||
a.compare_exchange_strong(t, T(2), std::memory_order_release, std::memory_order_relaxed);
|
||||
assert(y == true);
|
||||
assert(a == T(2));
|
||||
assert(t == T(1));
|
||||
y = a.compare_exchange_strong(t, T(3), std::memory_order_release, std::memory_order_relaxed);
|
||||
assert(y == false);
|
||||
assert(a == T(2));
|
||||
assert(t == T(2));
|
||||
|
||||
ASSERT_NOEXCEPT(a.compare_exchange_strong(t, T(2), std::memory_order_release, std::memory_order_relaxed));
|
||||
}
|
||||
|
||||
// success memory_order::release
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::release, std::memory_order::relaxed);
|
||||
assert(r);
|
||||
};
|
||||
|
||||
auto load = [](std::atomic_ref<T> const& x) { return x.load(std::memory_order::acquire); };
|
||||
test_acquire_release<T>(store, load);
|
||||
|
||||
auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::release);
|
||||
assert(r);
|
||||
};
|
||||
test_acquire_release<T>(store_one_arg, load);
|
||||
}
|
||||
|
||||
// success memory_order::acquire
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::release); };
|
||||
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_strong(val, val, std::memory_order::acquire, std::memory_order::relaxed)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_acquire_release<T>(store, load);
|
||||
|
||||
auto load_one_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_strong(val, val, std::memory_order::acquire)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_acquire_release<T>(store, load_one_arg);
|
||||
}
|
||||
|
||||
// success memory_order::acq_rel
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::acq_rel, std::memory_order::relaxed);
|
||||
assert(r);
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_strong(val, val, std::memory_order::acq_rel, std::memory_order::relaxed)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_acquire_release<T>(store, load);
|
||||
|
||||
auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::acq_rel);
|
||||
assert(r);
|
||||
};
|
||||
auto load_one_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_strong(val, val, std::memory_order::acq_rel)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_acquire_release<T>(store_one_arg, load_one_arg);
|
||||
}
|
||||
|
||||
// success memory_order::seq_cst
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::seq_cst, std::memory_order::relaxed);
|
||||
assert(r);
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_strong(val, val, std::memory_order::seq_cst, std::memory_order::relaxed)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_seq_cst<T>(store, load);
|
||||
|
||||
auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
auto r = x.compare_exchange_strong(old_val, new_val, std::memory_order::seq_cst);
|
||||
assert(r);
|
||||
};
|
||||
auto load_one_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_strong(val, val, std::memory_order::seq_cst)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_seq_cst<T>(store_one_arg, load_one_arg);
|
||||
}
|
||||
|
||||
// failure memory_order::acquire
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::release); };
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
T unexpected(T(255));
|
||||
bool r =
|
||||
x.compare_exchange_strong(unexpected, unexpected, std::memory_order::relaxed, std::memory_order::acquire);
|
||||
assert(!r);
|
||||
return result;
|
||||
};
|
||||
test_acquire_release<T>(store, load);
|
||||
|
||||
auto load_one_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
T unexpected(T(255));
|
||||
bool r = x.compare_exchange_strong(unexpected, unexpected, std::memory_order::acquire);
|
||||
assert(!r);
|
||||
return result;
|
||||
};
|
||||
test_acquire_release<T>(store, load_one_arg);
|
||||
|
||||
// acq_rel replaced by acquire
|
||||
auto load_one_arg_acq_rel = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
T unexpected(T(255));
|
||||
bool r = x.compare_exchange_strong(unexpected, unexpected, std::memory_order::acq_rel);
|
||||
assert(!r);
|
||||
return result;
|
||||
};
|
||||
test_acquire_release<T>(store, load_one_arg_acq_rel);
|
||||
}
|
||||
|
||||
// failure memory_order::seq_cst
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::seq_cst); };
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
T unexpected(T(255));
|
||||
bool r =
|
||||
x.compare_exchange_strong(unexpected, unexpected, std::memory_order::relaxed, std::memory_order::seq_cst);
|
||||
assert(!r);
|
||||
return result;
|
||||
};
|
||||
test_seq_cst<T>(store, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestCompareExchangeStrong>()();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,226 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// bool compare_exchange_weak(T&, T, memory_order, memory_order) const noexcept;
|
||||
// bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <concepts>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestCompareExchangeWeak {
|
||||
void operator()() const {
|
||||
{
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
T t(T(1));
|
||||
std::same_as<bool> decltype(auto) y = a.compare_exchange_weak(t, T(2));
|
||||
assert(y == true);
|
||||
assert(a == T(2));
|
||||
assert(t == T(1));
|
||||
y = a.compare_exchange_weak(t, T(3));
|
||||
assert(y == false);
|
||||
assert(a == T(2));
|
||||
assert(t == T(2));
|
||||
|
||||
ASSERT_NOEXCEPT(a.compare_exchange_weak(t, T(2)));
|
||||
}
|
||||
{
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
T t(T(1));
|
||||
std::same_as<bool> decltype(auto) y = a.compare_exchange_weak(t, T(2), std::memory_order_seq_cst);
|
||||
assert(y == true);
|
||||
assert(a == T(2));
|
||||
assert(t == T(1));
|
||||
y = a.compare_exchange_weak(t, T(3), std::memory_order_seq_cst);
|
||||
assert(y == false);
|
||||
assert(a == T(2));
|
||||
assert(t == T(2));
|
||||
|
||||
ASSERT_NOEXCEPT(a.compare_exchange_weak(t, T(2), std::memory_order_seq_cst));
|
||||
}
|
||||
{
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
T t(T(1));
|
||||
std::same_as<bool> decltype(auto) y =
|
||||
a.compare_exchange_weak(t, T(2), std::memory_order_release, std::memory_order_relaxed);
|
||||
assert(y == true);
|
||||
assert(a == T(2));
|
||||
assert(t == T(1));
|
||||
y = a.compare_exchange_weak(t, T(3), std::memory_order_release, std::memory_order_relaxed);
|
||||
assert(y == false);
|
||||
assert(a == T(2));
|
||||
assert(t == T(2));
|
||||
|
||||
ASSERT_NOEXCEPT(a.compare_exchange_weak(t, T(2), std::memory_order_release, std::memory_order_relaxed));
|
||||
}
|
||||
|
||||
// success memory_order::release
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
// could fail spuriously, so put it in a loop
|
||||
while (!x.compare_exchange_weak(old_val, new_val, std::memory_order::release, std::memory_order::relaxed)) {
|
||||
}
|
||||
};
|
||||
|
||||
auto load = [](std::atomic_ref<T> const& x) { return x.load(std::memory_order::acquire); };
|
||||
test_acquire_release<T>(store, load);
|
||||
|
||||
auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
// could fail spuriously, so put it in a loop
|
||||
while (!x.compare_exchange_weak(old_val, new_val, std::memory_order::release)) {
|
||||
}
|
||||
};
|
||||
test_acquire_release<T>(store_one_arg, load);
|
||||
}
|
||||
|
||||
// success memory_order::acquire
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::release); };
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_weak(val, val, std::memory_order::acquire, std::memory_order::relaxed)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_acquire_release<T>(store, load);
|
||||
|
||||
auto load_one_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_weak(val, val, std::memory_order::acquire)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_acquire_release<T>(store, load_one_arg);
|
||||
}
|
||||
|
||||
// success memory_order::acq_rel
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
// could fail spuriously, so put it in a loop
|
||||
while (!x.compare_exchange_weak(old_val, new_val, std::memory_order::acq_rel, std::memory_order::relaxed)) {
|
||||
}
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_weak(val, val, std::memory_order::acq_rel, std::memory_order::relaxed)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_acquire_release<T>(store, load);
|
||||
|
||||
auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
// could fail spuriously, so put it in a loop
|
||||
while (!x.compare_exchange_weak(old_val, new_val, std::memory_order::acq_rel)) {
|
||||
}
|
||||
};
|
||||
auto load_one_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_weak(val, val, std::memory_order::acq_rel)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_acquire_release<T>(store_one_arg, load_one_arg);
|
||||
}
|
||||
|
||||
// success memory_order::seq_cst
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
// could fail spuriously, so put it in a loop
|
||||
while (!x.compare_exchange_weak(old_val, new_val, std::memory_order::seq_cst, std::memory_order::relaxed)) {
|
||||
}
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_weak(val, val, std::memory_order::seq_cst, std::memory_order::relaxed)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_seq_cst<T>(store, load);
|
||||
|
||||
auto store_one_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
// could fail spuriously, so put it in a loop
|
||||
while (!x.compare_exchange_weak(old_val, new_val, std::memory_order::seq_cst)) {
|
||||
}
|
||||
};
|
||||
auto load_one_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto val = x.load(std::memory_order::relaxed);
|
||||
while (!x.compare_exchange_weak(val, val, std::memory_order::seq_cst)) {
|
||||
}
|
||||
return val;
|
||||
};
|
||||
test_seq_cst<T>(store_one_arg, load_one_arg);
|
||||
}
|
||||
|
||||
// failure memory_order::acquire
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::release); };
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
T unexpected(T(255));
|
||||
bool r =
|
||||
x.compare_exchange_weak(unexpected, unexpected, std::memory_order::relaxed, std::memory_order::acquire);
|
||||
assert(!r);
|
||||
return result;
|
||||
};
|
||||
test_acquire_release<T>(store, load);
|
||||
|
||||
auto load_one_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
T unexpected(T(255));
|
||||
bool r = x.compare_exchange_weak(unexpected, unexpected, std::memory_order::acquire);
|
||||
assert(!r);
|
||||
return result;
|
||||
};
|
||||
test_acquire_release<T>(store, load_one_arg);
|
||||
|
||||
// acq_rel replaced by acquire
|
||||
auto load_one_arg_acq_rel = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
T unexpected(T(255));
|
||||
bool r = x.compare_exchange_weak(unexpected, unexpected, std::memory_order::acq_rel);
|
||||
assert(!r);
|
||||
return result;
|
||||
};
|
||||
test_acquire_release<T>(store, load_one_arg_acq_rel);
|
||||
}
|
||||
|
||||
// failure memory_order::seq_cst
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::seq_cst); };
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
T unexpected(T(255));
|
||||
bool r =
|
||||
x.compare_exchange_weak(unexpected, unexpected, std::memory_order::relaxed, std::memory_order::seq_cst);
|
||||
assert(!r);
|
||||
return result;
|
||||
};
|
||||
test_seq_cst<T>(store, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestCompareExchangeWeak>()();
|
||||
return 0;
|
||||
}
|
||||
45
libcxx/test/std/atomics/atomics.ref/convert.pass.cpp
Normal file
45
libcxx/test/std/atomics/atomics.ref/convert.pass.cpp
Normal file
@@ -0,0 +1,45 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// operator T() const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestConvert {
|
||||
void operator()() const {
|
||||
T x(T(1));
|
||||
|
||||
T copy = x;
|
||||
std::atomic_ref<T> const a(copy);
|
||||
|
||||
T converted = a;
|
||||
assert(converted == x);
|
||||
|
||||
ASSERT_NOEXCEPT(T(a));
|
||||
static_assert(std::is_nothrow_convertible_v<std::atomic_ref<T>, T>);
|
||||
|
||||
auto store = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val); };
|
||||
auto load = [](std::atomic_ref<T> const& y) { return static_cast<T>(y); };
|
||||
test_seq_cst<T>(store, load);
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestConvert>()();
|
||||
return 0;
|
||||
}
|
||||
37
libcxx/test/std/atomics/atomics.ref/ctor.pass.cpp
Normal file
37
libcxx/test/std/atomics/atomics.ref/ctor.pass.cpp
Normal file
@@ -0,0 +1,37 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
|
||||
// <atomic>
|
||||
|
||||
// explicit atomic_ref(T&);
|
||||
|
||||
#include <atomic>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestCtor {
|
||||
void operator()() const {
|
||||
// check that the constructor is explicit
|
||||
static_assert(!std::is_convertible_v<T, std::atomic_ref<T>>);
|
||||
static_assert(std::is_constructible_v<std::atomic_ref<T>, T&>);
|
||||
|
||||
T x(T(0));
|
||||
std::atomic_ref<T> a(x);
|
||||
(void)a;
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestCtor>()();
|
||||
return 0;
|
||||
}
|
||||
33
libcxx/test/std/atomics/atomics.ref/deduction.pass.cpp
Normal file
33
libcxx/test/std/atomics/atomics.ref/deduction.pass.cpp
Normal file
@@ -0,0 +1,33 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
|
||||
// <atomic>
|
||||
|
||||
// explicit atomic_ref(T&);
|
||||
|
||||
#include <atomic>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestDeduction {
|
||||
void operator()() const {
|
||||
T x(T(0));
|
||||
std::atomic_ref a(x);
|
||||
ASSERT_SAME_TYPE(decltype(a), std::atomic_ref<T>);
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestDeduction>()();
|
||||
return 0;
|
||||
}
|
||||
45
libcxx/test/std/atomics/atomics.ref/exchange.pass.cpp
Normal file
45
libcxx/test/std/atomics/atomics.ref/exchange.pass.cpp
Normal file
@@ -0,0 +1,45 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// T exchange(T, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestExchange {
|
||||
void operator()() const {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.exchange(T(2));
|
||||
assert(y == T(1));
|
||||
ASSERT_NOEXCEPT(a.exchange(T(2)));
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.exchange(T(3), std::memory_order_seq_cst);
|
||||
assert(y == T(2));
|
||||
ASSERT_NOEXCEPT(a.exchange(T(3), std::memory_order_seq_cst));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestExchange>()();
|
||||
return 0;
|
||||
}
|
||||
113
libcxx/test/std/atomics/atomics.ref/fetch_add.pass.cpp
Normal file
113
libcxx/test/std/atomics/atomics.ref/fetch_add.pass.cpp
Normal file
@@ -0,0 +1,113 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type fetch_add(integral-type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
// floating-point-type fetch_add(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
// T* fetch_add(difference_type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_fetch_add = requires {
|
||||
std::declval<T const>().fetch_add(std::declval<T>());
|
||||
std::declval<T const>().fetch_add(std::declval<T>(), std::declval<std::memory_order>());
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveFetchAdd {
|
||||
void operator()() const { static_assert(!has_fetch_add<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestFetchAdd {
|
||||
void operator()() const {
|
||||
if constexpr (std::is_arithmetic_v<T>) {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_add(T(2));
|
||||
assert(y == T(1));
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a.fetch_add(T(0)));
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_add(T(4), std::memory_order_relaxed);
|
||||
assert(y == T(3));
|
||||
assert(x == T(7));
|
||||
ASSERT_NOEXCEPT(a.fetch_add(T(0), std::memory_order_relaxed));
|
||||
}
|
||||
} else if constexpr (std::is_pointer_v<T>) {
|
||||
using U = std::remove_pointer_t<T>;
|
||||
U t[9] = {};
|
||||
T p{&t[1]};
|
||||
std::atomic_ref<T> const a(p);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_add(2);
|
||||
assert(y == &t[1]);
|
||||
assert(a == &t[3]);
|
||||
ASSERT_NOEXCEPT(a.fetch_add(0));
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_add(4, std::memory_order_relaxed);
|
||||
assert(y == &t[3]);
|
||||
assert(a == &t[7]);
|
||||
ASSERT_NOEXCEPT(a.fetch_add(0, std::memory_order_relaxed));
|
||||
}
|
||||
} else {
|
||||
static_assert(std::is_void_v<T>);
|
||||
}
|
||||
|
||||
// memory_order::release
|
||||
{
|
||||
auto fetch_add = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
x.fetch_add(new_val - old_val, std::memory_order::release);
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& x) { return x.load(std::memory_order::acquire); };
|
||||
test_acquire_release<T>(fetch_add, load);
|
||||
}
|
||||
|
||||
// memory_order::seq_cst
|
||||
{
|
||||
auto fetch_add_no_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) { x.fetch_add(new_val - old_val); };
|
||||
auto fetch_add_with_order = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
x.fetch_add(new_val - old_val, std::memory_order::seq_cst);
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& x) { return x.load(); };
|
||||
test_seq_cst<T>(fetch_add_no_arg, load);
|
||||
test_seq_cst<T>(fetch_add_with_order, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestFetchAdd>()();
|
||||
|
||||
TestFetchAdd<float>()();
|
||||
TestFetchAdd<double>()();
|
||||
|
||||
TestEachPointerType<TestFetchAdd>()();
|
||||
|
||||
TestDoesNotHaveFetchAdd<bool>()();
|
||||
TestDoesNotHaveFetchAdd<UserAtomicType>()();
|
||||
TestDoesNotHaveFetchAdd<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
69
libcxx/test/std/atomics/atomics.ref/fetch_and.pass.cpp
Normal file
69
libcxx/test/std/atomics/atomics.ref/fetch_and.pass.cpp
Normal file
@@ -0,0 +1,69 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type fetch_and(integral-type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_fetch_and = requires {
|
||||
std::declval<T const>().fetch_and(std::declval<T>());
|
||||
std::declval<T const>().fetch_and(std::declval<T>(), std::declval<std::memory_order>());
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveFetchAnd {
|
||||
void operator()() const { static_assert(!has_fetch_and<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestFetchAnd {
|
||||
void operator()() const {
|
||||
static_assert(std::is_integral_v<T>);
|
||||
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_and(T(2));
|
||||
assert(y == T(1));
|
||||
assert(x == T(0));
|
||||
ASSERT_NOEXCEPT(a.fetch_and(T(0)));
|
||||
}
|
||||
|
||||
x = T(1);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_and(T(2), std::memory_order_relaxed);
|
||||
assert(y == T(1));
|
||||
assert(x == T(0));
|
||||
ASSERT_NOEXCEPT(a.fetch_and(T(0), std::memory_order_relaxed));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestFetchAnd>()();
|
||||
|
||||
TestEachFloatingPointType<TestDoesNotHaveFetchAnd>()();
|
||||
|
||||
TestEachPointerType<TestDoesNotHaveFetchAnd>()();
|
||||
|
||||
TestDoesNotHaveFetchAnd<bool>()();
|
||||
TestDoesNotHaveFetchAnd<UserAtomicType>()();
|
||||
TestDoesNotHaveFetchAnd<LargeUserAtomicType>()();
|
||||
return 0;
|
||||
}
|
||||
68
libcxx/test/std/atomics/atomics.ref/fetch_or.pass.cpp
Normal file
68
libcxx/test/std/atomics/atomics.ref/fetch_or.pass.cpp
Normal file
@@ -0,0 +1,68 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type fetch_or(integral-type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <concepts>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_fetch_or = requires {
|
||||
std::declval<T const>().fetch_or(std::declval<T>());
|
||||
std::declval<T const>().fetch_or(std::declval<T>(), std::declval<std::memory_order>());
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveFetchOr {
|
||||
void operator()() const { static_assert(!has_fetch_or<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestFetchOr {
|
||||
void operator()() const {
|
||||
static_assert(std::is_integral_v<T>);
|
||||
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_or(T(2));
|
||||
assert(y == T(1));
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a.fetch_or(T(0)));
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_or(T(2), std::memory_order_relaxed);
|
||||
assert(y == T(3));
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a.fetch_or(T(0), std::memory_order_relaxed));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestFetchOr>()();
|
||||
|
||||
TestEachFloatingPointType<TestDoesNotHaveFetchOr>()();
|
||||
|
||||
TestEachPointerType<TestDoesNotHaveFetchOr>()();
|
||||
|
||||
TestDoesNotHaveFetchOr<bool>()();
|
||||
TestDoesNotHaveFetchOr<UserAtomicType>()();
|
||||
TestDoesNotHaveFetchOr<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
113
libcxx/test/std/atomics/atomics.ref/fetch_sub.pass.cpp
Normal file
113
libcxx/test/std/atomics/atomics.ref/fetch_sub.pass.cpp
Normal file
@@ -0,0 +1,113 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type fetch_sub(integral-type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
// floating-point-type fetch_sub(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
// T* fetch_sub(difference_type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_fetch_sub = requires {
|
||||
std::declval<T const>().fetch_sub(std::declval<T>());
|
||||
std::declval<T const>().fetch_sub(std::declval<T>(), std::declval<std::memory_order>());
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveFetchSub {
|
||||
void operator()() const { static_assert(!has_fetch_sub<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestFetchSub {
|
||||
void operator()() const {
|
||||
if constexpr (std::is_arithmetic_v<T>) {
|
||||
T x(T(7));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_sub(T(4));
|
||||
assert(y == T(7));
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a.fetch_sub(T(0)));
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_sub(T(2), std::memory_order_relaxed);
|
||||
assert(y == T(3));
|
||||
assert(x == T(1));
|
||||
ASSERT_NOEXCEPT(a.fetch_sub(T(0), std::memory_order_relaxed));
|
||||
}
|
||||
} else if constexpr (std::is_pointer_v<T>) {
|
||||
using U = std::remove_pointer_t<T>;
|
||||
U t[9] = {};
|
||||
T p{&t[7]};
|
||||
std::atomic_ref<T> const a(p);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_sub(4);
|
||||
assert(y == &t[7]);
|
||||
assert(a == &t[3]);
|
||||
ASSERT_NOEXCEPT(a.fetch_sub(0));
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_sub(2, std::memory_order_relaxed);
|
||||
assert(y == &t[3]);
|
||||
assert(a == &t[1]);
|
||||
ASSERT_NOEXCEPT(a.fetch_sub(0, std::memory_order_relaxed));
|
||||
}
|
||||
} else {
|
||||
static_assert(std::is_void_v<T>);
|
||||
}
|
||||
|
||||
// memory_order::release
|
||||
{
|
||||
auto fetch_sub = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
x.fetch_sub(old_val - new_val, std::memory_order::release);
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& x) { return x.load(std::memory_order::acquire); };
|
||||
test_acquire_release<T>(fetch_sub, load);
|
||||
}
|
||||
|
||||
// memory_order::seq_cst
|
||||
{
|
||||
auto fetch_sub_no_arg = [](std::atomic_ref<T> const& x, T old_val, T new_val) { x.fetch_sub(old_val - new_val); };
|
||||
auto fetch_sub_with_order = [](std::atomic_ref<T> const& x, T old_val, T new_val) {
|
||||
x.fetch_sub(old_val - new_val, std::memory_order::seq_cst);
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& x) { return x.load(); };
|
||||
test_seq_cst<T>(fetch_sub_no_arg, load);
|
||||
test_seq_cst<T>(fetch_sub_with_order, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestFetchSub>()();
|
||||
|
||||
TestFetchSub<float>()();
|
||||
TestFetchSub<double>()();
|
||||
|
||||
TestEachPointerType<TestFetchSub>()();
|
||||
|
||||
TestDoesNotHaveFetchSub<bool>()();
|
||||
TestDoesNotHaveFetchSub<UserAtomicType>()();
|
||||
TestDoesNotHaveFetchSub<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
68
libcxx/test/std/atomics/atomics.ref/fetch_xor.pass.cpp
Normal file
68
libcxx/test/std/atomics/atomics.ref/fetch_xor.pass.cpp
Normal file
@@ -0,0 +1,68 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type fetch_xor(integral-type, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <concepts>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_fetch_xor = requires {
|
||||
std::declval<T const>().fetch_xor(std::declval<T>());
|
||||
std::declval<T const>().fetch_xor(std::declval<T>(), std::declval<std::memory_order>());
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveFetchXor {
|
||||
void operator()() const { static_assert(!has_fetch_xor<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestFetchXor {
|
||||
void operator()() const {
|
||||
static_assert(std::is_integral_v<T>);
|
||||
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_xor(T(2));
|
||||
assert(y == T(1));
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a.fetch_xor(T(0)));
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.fetch_xor(T(2), std::memory_order_relaxed);
|
||||
assert(y == T(3));
|
||||
assert(x == T(1));
|
||||
ASSERT_NOEXCEPT(a.fetch_xor(T(0), std::memory_order_relaxed));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestFetchXor>()();
|
||||
|
||||
TestEachFloatingPointType<TestDoesNotHaveFetchXor>()();
|
||||
|
||||
TestEachPointerType<TestDoesNotHaveFetchXor>()();
|
||||
|
||||
TestDoesNotHaveFetchXor<bool>()();
|
||||
TestDoesNotHaveFetchXor<UserAtomicType>()();
|
||||
TestDoesNotHaveFetchXor<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type operator++(int) const noexcept;
|
||||
// integral-type operator--(int) const noexcept;
|
||||
// integral-type operator++() const noexcept;
|
||||
// integral-type operator--() const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_pre_increment_operator = requires { ++std::declval<T const>(); };
|
||||
|
||||
template <typename T>
|
||||
concept has_post_increment_operator = requires { std::declval<T const>()++; };
|
||||
|
||||
template <typename T>
|
||||
concept has_pre_decrement_operator = requires { --std::declval<T const>(); };
|
||||
|
||||
template <typename T>
|
||||
concept has_post_decrement_operator = requires { std::declval<T const>()--; };
|
||||
|
||||
template <typename T>
|
||||
constexpr bool does_not_have_increment_nor_decrement_operators() {
|
||||
return !has_pre_increment_operator<T> && !has_pre_decrement_operator<T> && !has_post_increment_operator<T> &&
|
||||
!has_post_decrement_operator<T>;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveIncrementDecrement {
|
||||
void operator()() const { static_assert(does_not_have_increment_nor_decrement_operators<T>()); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestIncrementDecrement {
|
||||
void operator()() const {
|
||||
static_assert(std::is_integral_v<T>);
|
||||
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = ++a;
|
||||
assert(y == T(2));
|
||||
assert(x == T(2));
|
||||
ASSERT_NOEXCEPT(++a);
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = --a;
|
||||
assert(y == T(1));
|
||||
assert(x == T(1));
|
||||
ASSERT_NOEXCEPT(--a);
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a++;
|
||||
assert(y == T(1));
|
||||
assert(x == T(2));
|
||||
ASSERT_NOEXCEPT(a++);
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a--;
|
||||
assert(y == T(2));
|
||||
assert(x == T(1));
|
||||
ASSERT_NOEXCEPT(a--);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestIncrementDecrement>()();
|
||||
|
||||
TestEachFloatingPointType<TestDoesNotHaveIncrementDecrement>()();
|
||||
|
||||
TestEachPointerType<TestDoesNotHaveIncrementDecrement>()();
|
||||
|
||||
TestDoesNotHaveIncrementDecrement<bool>()();
|
||||
TestDoesNotHaveIncrementDecrement<UserAtomicType>()();
|
||||
TestDoesNotHaveIncrementDecrement<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
|
||||
// <atomic>
|
||||
|
||||
// static constexpr bool is_always_lock_free;
|
||||
// bool is_lock_free() const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
void check_always_lock_free(std::atomic_ref<T> const a) {
|
||||
std::same_as<const bool> decltype(auto) is_always_lock_free = std::atomic_ref<T>::is_always_lock_free;
|
||||
if (is_always_lock_free) {
|
||||
std::same_as<bool> decltype(auto) is_lock_free = a.is_lock_free();
|
||||
assert(is_lock_free);
|
||||
}
|
||||
ASSERT_NOEXCEPT(a.is_lock_free());
|
||||
}
|
||||
|
||||
#define CHECK_ALWAYS_LOCK_FREE(T) \
|
||||
do { \
|
||||
typedef T type; \
|
||||
type obj{}; \
|
||||
check_always_lock_free(std::atomic_ref<type>(obj)); \
|
||||
} while (0)
|
||||
|
||||
void test() {
|
||||
int i = 0;
|
||||
check_always_lock_free(std::atomic_ref<int>(i));
|
||||
|
||||
float f = 0.f;
|
||||
check_always_lock_free(std::atomic_ref<float>(f));
|
||||
|
||||
int* p = &i;
|
||||
check_always_lock_free(std::atomic_ref<int*>(p));
|
||||
|
||||
CHECK_ALWAYS_LOCK_FREE(struct Empty{});
|
||||
CHECK_ALWAYS_LOCK_FREE(struct OneInt { int i; });
|
||||
CHECK_ALWAYS_LOCK_FREE(struct IntArr2 { int i[2]; });
|
||||
CHECK_ALWAYS_LOCK_FREE(struct FloatArr3 { float i[3]; });
|
||||
CHECK_ALWAYS_LOCK_FREE(struct LLIArr2 { long long int i[2]; });
|
||||
CHECK_ALWAYS_LOCK_FREE(struct LLIArr4 { long long int i[4]; });
|
||||
CHECK_ALWAYS_LOCK_FREE(struct LLIArr8 { long long int i[8]; });
|
||||
CHECK_ALWAYS_LOCK_FREE(struct LLIArr16 { long long int i[16]; });
|
||||
CHECK_ALWAYS_LOCK_FREE(struct Padding {
|
||||
char c; /* padding */
|
||||
long long int i;
|
||||
});
|
||||
CHECK_ALWAYS_LOCK_FREE(union IntFloat {
|
||||
int i;
|
||||
float f;
|
||||
});
|
||||
CHECK_ALWAYS_LOCK_FREE(enum class CharEnumClass : char{foo});
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
test();
|
||||
return 0;
|
||||
}
|
||||
62
libcxx/test/std/atomics/atomics.ref/load.pass.cpp
Normal file
62
libcxx/test/std/atomics/atomics.ref/load.pass.cpp
Normal file
@@ -0,0 +1,62 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// T load(memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <concepts>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestLoad {
|
||||
void operator()() const {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.load();
|
||||
assert(y == T(1));
|
||||
ASSERT_NOEXCEPT(a.load());
|
||||
}
|
||||
|
||||
{
|
||||
std::same_as<T> decltype(auto) y = a.load(std::memory_order_seq_cst);
|
||||
assert(y == T(1));
|
||||
ASSERT_NOEXCEPT(a.load(std::memory_order_seq_cst));
|
||||
}
|
||||
|
||||
// memory_order::seq_cst
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val); };
|
||||
auto load_no_arg = [](std::atomic_ref<T> const& y) { return y.load(); };
|
||||
auto load_with_order = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::seq_cst); };
|
||||
test_seq_cst<T>(store, load_no_arg);
|
||||
test_seq_cst<T>(store, load_with_order);
|
||||
}
|
||||
|
||||
// memory_order::release
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val, std::memory_order::release); };
|
||||
auto load = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::acquire); };
|
||||
test_acquire_release<T>(store, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestLoad>()();
|
||||
return 0;
|
||||
}
|
||||
132
libcxx/test/std/atomics/atomics.ref/member_types.pass.cpp
Normal file
132
libcxx/test/std/atomics/atomics.ref/member_types.pass.cpp
Normal file
@@ -0,0 +1,132 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
|
||||
|
||||
// <atomic>
|
||||
|
||||
// template <class T>
|
||||
// struct atomic_ref
|
||||
// {
|
||||
// using value_type = T;
|
||||
// using difference_type = value_type; // only for atomic_ref<Integral> and
|
||||
// // atomic_ref<Floating> specializations
|
||||
// using difference_type = std::ptrdiff_t; // only for atomic_ref<T*> specializations
|
||||
//
|
||||
// explicit atomic_ref(T&);
|
||||
// atomic_ref(const atomic_ref&) noexcept;
|
||||
// atomic_ref& operator=(const atomic_ref&) = delete;
|
||||
// };
|
||||
|
||||
#include <atomic>
|
||||
#include <type_traits>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
template <class T>
|
||||
concept has_difference_type = requires { typename T::difference_type; };
|
||||
|
||||
template <class T>
|
||||
void check_member_types() {
|
||||
if constexpr ((std::is_integral_v<T> && !std::is_same_v<T, bool>) || std::is_floating_point_v<T>) {
|
||||
ASSERT_SAME_TYPE(typename std::atomic_ref<T>::value_type, T);
|
||||
ASSERT_SAME_TYPE(typename std::atomic_ref<T>::difference_type, T);
|
||||
} else if constexpr (std::is_pointer_v<T>) {
|
||||
ASSERT_SAME_TYPE(typename std::atomic_ref<T>::value_type, T);
|
||||
ASSERT_SAME_TYPE(typename std::atomic_ref<T>::difference_type, std::ptrdiff_t);
|
||||
} else {
|
||||
ASSERT_SAME_TYPE(typename std::atomic_ref<T>::value_type, T);
|
||||
static_assert(!has_difference_type<std::atomic_ref<T>>);
|
||||
}
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test() {
|
||||
// value_type and difference_type (except for primary template)
|
||||
check_member_types<T>();
|
||||
|
||||
static_assert(std::is_nothrow_copy_constructible_v<std::atomic_ref<T>>);
|
||||
|
||||
static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
|
||||
|
||||
// explicit constructor
|
||||
static_assert(!std::is_convertible_v<T, std::atomic_ref<T>>);
|
||||
static_assert(std::is_constructible_v<std::atomic_ref<T>, T&>);
|
||||
}
|
||||
|
||||
void testall() {
|
||||
// Primary template
|
||||
struct Empty {};
|
||||
test<Empty>();
|
||||
struct Trivial {
|
||||
int a;
|
||||
float b;
|
||||
};
|
||||
test<Trivial>();
|
||||
test<bool>();
|
||||
|
||||
// Partial specialization for pointer types
|
||||
test<void*>();
|
||||
|
||||
// Specialization for integral types
|
||||
// + character types
|
||||
test<char>();
|
||||
test<char8_t>();
|
||||
test<char16_t>();
|
||||
test<char32_t>();
|
||||
test<wchar_t>();
|
||||
// + standard signed integer types
|
||||
test<signed char>();
|
||||
test<short>();
|
||||
test<int>();
|
||||
test<long>();
|
||||
test<long long>();
|
||||
// + standard unsigned integer types
|
||||
test<unsigned char>();
|
||||
test<unsigned short>();
|
||||
test<unsigned int>();
|
||||
test<unsigned long>();
|
||||
test<unsigned long long>();
|
||||
// + any other types needed by the typedefs in the header <cstdint>
|
||||
test<int8_t>();
|
||||
test<int16_t>();
|
||||
test<int32_t>();
|
||||
test<int64_t>();
|
||||
test<int_fast8_t>();
|
||||
test<int_fast16_t>();
|
||||
test<int_fast32_t>();
|
||||
test<int_fast64_t>();
|
||||
test<int_least8_t>();
|
||||
test<int_least16_t>();
|
||||
test<int_least32_t>();
|
||||
test<int_least64_t>();
|
||||
test<intmax_t>();
|
||||
test<intptr_t>();
|
||||
test<uint8_t>();
|
||||
test<uint16_t>();
|
||||
test<uint32_t>();
|
||||
test<uint64_t>();
|
||||
test<uint_fast8_t>();
|
||||
test<uint_fast16_t>();
|
||||
test<uint_fast32_t>();
|
||||
test<uint_fast64_t>();
|
||||
test<uint_least8_t>();
|
||||
test<uint_least16_t>();
|
||||
test<uint_least32_t>();
|
||||
test<uint_least64_t>();
|
||||
test<uintmax_t>();
|
||||
test<uintptr_t>();
|
||||
|
||||
// Specialization for floating-point types
|
||||
// + floating-point types
|
||||
test<float>();
|
||||
test<double>();
|
||||
test<long double>();
|
||||
// + TODO extended floating-point types
|
||||
}
|
||||
|
||||
int main(int, char**) { return 0; }
|
||||
78
libcxx/test/std/atomics/atomics.ref/notify_all.pass.cpp
Normal file
78
libcxx/test/std/atomics/atomics.ref/notify_all.pass.cpp
Normal file
@@ -0,0 +1,78 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: no-threads
|
||||
// XFAIL: availability-synchronization_library-missing
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// void notify_all() const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <thread>
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "make_test_thread.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestNotifyAll {
|
||||
void operator()() const {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
bool done = false;
|
||||
std::atomic<int> started_num = 0;
|
||||
std::atomic<int> wait_done_num = 0;
|
||||
|
||||
constexpr auto number_of_threads = 8;
|
||||
std::vector<std::thread> threads;
|
||||
threads.reserve(number_of_threads);
|
||||
|
||||
for (auto j = 0; j < number_of_threads; ++j) {
|
||||
threads.push_back(support::make_test_thread([&a, &started_num, &done, &wait_done_num] {
|
||||
started_num.fetch_add(1, std::memory_order::relaxed);
|
||||
|
||||
a.wait(T(1));
|
||||
wait_done_num.fetch_add(1, std::memory_order::relaxed);
|
||||
|
||||
// likely to fail if wait did not block
|
||||
assert(done);
|
||||
}));
|
||||
}
|
||||
|
||||
while (started_num.load(std::memory_order::relaxed) != number_of_threads) {
|
||||
std::this_thread::yield();
|
||||
}
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
||||
|
||||
done = true;
|
||||
a.store(T(3));
|
||||
a.notify_all();
|
||||
|
||||
// notify_all should unblock all the threads so that the loop below won't stuck
|
||||
while (wait_done_num.load(std::memory_order::relaxed) != number_of_threads) {
|
||||
std::this_thread::yield();
|
||||
}
|
||||
|
||||
for (auto& thread : threads) {
|
||||
thread.join();
|
||||
}
|
||||
|
||||
ASSERT_NOEXCEPT(a.notify_all());
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestNotifyAll>()();
|
||||
return 0;
|
||||
}
|
||||
46
libcxx/test/std/atomics/atomics.ref/notify_one.pass.cpp
Normal file
46
libcxx/test/std/atomics/atomics.ref/notify_one.pass.cpp
Normal file
@@ -0,0 +1,46 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: no-threads
|
||||
// XFAIL: availability-synchronization_library-missing
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// void notify_one() const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <thread>
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "make_test_thread.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestNotifyOne {
|
||||
void operator()() const {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
std::thread t = support::make_test_thread([&]() {
|
||||
a.store(T(3));
|
||||
a.notify_one();
|
||||
});
|
||||
a.wait(T(1));
|
||||
assert(a.load() == T(3));
|
||||
t.join();
|
||||
ASSERT_NOEXCEPT(a.notify_one());
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestNotifyOne>()();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type operator-=(integral-type) const noexcept;
|
||||
// floating-point-type operator-=(floating-point-type) const noexcept;
|
||||
// T* operator-=(difference_type) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_operator_minus_equals = requires { std::declval<T const>() -= std::declval<T>(); };
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveOperatorMinusEquals {
|
||||
void operator()() const { static_assert(!has_operator_minus_equals<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestOperatorMinusEquals {
|
||||
void operator()() const {
|
||||
if constexpr (std::is_arithmetic_v<T>) {
|
||||
T x(T(3));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
std::same_as<T> decltype(auto) y = (a -= T(2));
|
||||
assert(y == T(1));
|
||||
assert(x == T(1));
|
||||
ASSERT_NOEXCEPT(a -= T(0));
|
||||
} else if constexpr (std::is_pointer_v<T>) {
|
||||
using U = std::remove_pointer_t<T>;
|
||||
U t[9] = {};
|
||||
T p{&t[3]};
|
||||
std::atomic_ref<T> const a(p);
|
||||
|
||||
std::same_as<T> decltype(auto) y = (a -= 2);
|
||||
assert(y == &t[1]);
|
||||
assert(a == &t[1]);
|
||||
ASSERT_NOEXCEPT(a -= 0);
|
||||
} else {
|
||||
static_assert(std::is_void_v<T>);
|
||||
}
|
||||
|
||||
// memory_order::seq_cst
|
||||
{
|
||||
auto minus_equals = [](std::atomic_ref<T> const& x, T old_val, T new_val) { x -= (old_val - new_val); };
|
||||
auto load = [](std::atomic_ref<T> const& x) { return x.load(); };
|
||||
test_seq_cst<T>(minus_equals, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestOperatorMinusEquals>()();
|
||||
|
||||
TestOperatorMinusEquals<float>()();
|
||||
TestOperatorMinusEquals<double>()();
|
||||
|
||||
TestEachPointerType<TestOperatorMinusEquals>()();
|
||||
|
||||
TestDoesNotHaveOperatorMinusEquals<bool>()();
|
||||
TestDoesNotHaveOperatorMinusEquals<UserAtomicType>()();
|
||||
TestDoesNotHaveOperatorMinusEquals<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
|
||||
// integral-type operator+=(integral-type) const noexcept;
|
||||
// floating-point-type operator+=(floating-point-type) const noexcept;
|
||||
// T* operator+=(difference_type) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <concepts>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
concept has_operator_plus_equals = requires { std::declval<T const>() += std::declval<T>(); };
|
||||
|
||||
template <typename T>
|
||||
struct TestDoesNotHaveOperatorPlusEquals {
|
||||
void operator()() const { static_assert(!has_operator_plus_equals<std::atomic_ref<T>>); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TestOperatorPlusEquals {
|
||||
void operator()() const {
|
||||
if constexpr (std::is_arithmetic_v<T>) {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
std::same_as<T> decltype(auto) y = (a += T(2));
|
||||
assert(y == T(3));
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a += T(0));
|
||||
} else if constexpr (std::is_pointer_v<T>) {
|
||||
using U = std::remove_pointer_t<T>;
|
||||
U t[9] = {};
|
||||
T p{&t[1]};
|
||||
std::atomic_ref<T> const a(p);
|
||||
|
||||
std::same_as<T> decltype(auto) y = (a += 2);
|
||||
assert(y == &t[3]);
|
||||
assert(a == &t[3]);
|
||||
ASSERT_NOEXCEPT(a += 0);
|
||||
} else {
|
||||
static_assert(std::is_void_v<T>);
|
||||
}
|
||||
|
||||
// memory_order::seq_cst
|
||||
{
|
||||
auto plus_equals = [](std::atomic_ref<T> const& x, T old_val, T new_val) { x += (new_val - old_val); };
|
||||
auto load = [](std::atomic_ref<T> const& x) { return x.load(); };
|
||||
test_seq_cst<T>(plus_equals, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachIntegralType<TestOperatorPlusEquals>()();
|
||||
|
||||
TestOperatorPlusEquals<float>()();
|
||||
TestOperatorPlusEquals<double>()();
|
||||
|
||||
TestEachPointerType<TestOperatorPlusEquals>()();
|
||||
|
||||
TestDoesNotHaveOperatorPlusEquals<bool>()();
|
||||
TestDoesNotHaveOperatorPlusEquals<UserAtomicType>()();
|
||||
TestDoesNotHaveOperatorPlusEquals<LargeUserAtomicType>()();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
|
||||
// static constexpr size_t required_alignment;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <concepts>
|
||||
|
||||
template <typename T>
|
||||
constexpr void check_required_alignment() {
|
||||
std::same_as<const std::size_t> decltype(auto) required_alignment = std::atomic_ref<T>::required_alignment;
|
||||
assert(required_alignment >= alignof(T));
|
||||
}
|
||||
|
||||
constexpr bool test() {
|
||||
check_required_alignment<int>();
|
||||
check_required_alignment<float>();
|
||||
check_required_alignment<int*>();
|
||||
struct Empty {};
|
||||
check_required_alignment<Empty>();
|
||||
struct Trivial {
|
||||
int a;
|
||||
};
|
||||
check_required_alignment<Trivial>();
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
test();
|
||||
static_assert(test());
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
|
||||
// <atomic_ref>
|
||||
|
||||
// template<class T>
|
||||
// class atomic_ref;
|
||||
|
||||
// The program is ill-formed if is_trivially_copyable_v<T> is false.
|
||||
|
||||
#include <atomic>
|
||||
|
||||
void trivially_copyable() {
|
||||
struct X {
|
||||
X() = default;
|
||||
X(X const&) {} // -> not trivially copyable
|
||||
} x;
|
||||
// expected-error-re@*:* {{static assertion failed {{.*}}atomic_ref<T> requires that 'T' be a trivially copyable type}}
|
||||
std::atomic_ref<X> r(x);
|
||||
}
|
||||
61
libcxx/test/std/atomics/atomics.ref/store.pass.cpp
Normal file
61
libcxx/test/std/atomics/atomics.ref/store.pass.cpp
Normal file
@@ -0,0 +1,61 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// void store(T, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestStore {
|
||||
void operator()() const {
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
a.store(T(2));
|
||||
assert(x == T(2));
|
||||
ASSERT_NOEXCEPT(a.store(T(1)));
|
||||
|
||||
a.store(T(3), std::memory_order_seq_cst);
|
||||
assert(x == T(3));
|
||||
ASSERT_NOEXCEPT(a.store(T(0), std::memory_order_seq_cst));
|
||||
|
||||
// TODO memory_order::relaxed
|
||||
|
||||
// memory_order::seq_cst
|
||||
{
|
||||
auto store_no_arg = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val); };
|
||||
auto store_with_order = [](std::atomic_ref<T> const& y, T, T new_val) {
|
||||
y.store(new_val, std::memory_order::seq_cst);
|
||||
};
|
||||
auto load = [](std::atomic_ref<T> const& y) { return y.load(); };
|
||||
test_seq_cst<T>(store_no_arg, load);
|
||||
test_seq_cst<T>(store_with_order, load);
|
||||
}
|
||||
|
||||
// memory_order::release
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& y, T, T new_val) { y.store(new_val, std::memory_order::release); };
|
||||
auto load = [](std::atomic_ref<T> const& y) { return y.load(std::memory_order::acquire); };
|
||||
test_acquire_release<T>(store, load);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestStore>()();
|
||||
return 0;
|
||||
}
|
||||
136
libcxx/test/std/atomics/atomics.ref/test_helper.h
Normal file
136
libcxx/test/std/atomics/atomics.ref/test_helper.h
Normal file
@@ -0,0 +1,136 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef TEST_STD_ATOMICS_ATOMIC_REF_TEST_HELPER_H
|
||||
#define TEST_STD_ATOMICS_ATOMIC_REF_TEST_HELPER_H
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
#ifndef TEST_HAS_NO_THREADS
|
||||
# include "make_test_thread.h"
|
||||
# include <thread>
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
bool equals(T x, T y) {
|
||||
return x == y;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
T make_value(int i) {
|
||||
assert(i == 0 || i == 1);
|
||||
if constexpr (std::is_pointer_v<T>) {
|
||||
// So that pointers returned can be subtracted from one another
|
||||
static std::remove_const_t<std::remove_pointer_t<T>> d[2];
|
||||
return &d[i];
|
||||
} else {
|
||||
return T(i);
|
||||
}
|
||||
}
|
||||
|
||||
// Test that all threads see the exact same sequence of events
|
||||
// Test will pass 100% if store_op and load_op are correctly
|
||||
// affecting the memory with seq_cst order
|
||||
template <class T, class StoreOp, class LoadOp>
|
||||
void test_seq_cst(StoreOp store_op, LoadOp load_op) {
|
||||
#ifndef TEST_HAS_NO_THREADS
|
||||
for (int i = 0; i < 100; ++i) {
|
||||
T old_value(make_value<T>(0));
|
||||
T new_value(make_value<T>(1));
|
||||
|
||||
T copy_x = old_value;
|
||||
std::atomic_ref<T> const x(copy_x);
|
||||
T copy_y = old_value;
|
||||
std::atomic_ref<T> const y(copy_y);
|
||||
|
||||
std::atomic_bool x_updated_first(false);
|
||||
std::atomic_bool y_updated_first(false);
|
||||
|
||||
auto t1 = support::make_test_thread([&] { store_op(x, old_value, new_value); });
|
||||
|
||||
auto t2 = support::make_test_thread([&] { store_op(y, old_value, new_value); });
|
||||
|
||||
auto t3 = support::make_test_thread([&] {
|
||||
while (!equals(load_op(x), new_value)) {
|
||||
std::this_thread::yield();
|
||||
}
|
||||
if (!equals(load_op(y), new_value)) {
|
||||
x_updated_first.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
});
|
||||
|
||||
auto t4 = support::make_test_thread([&] {
|
||||
while (!equals(load_op(y), new_value)) {
|
||||
std::this_thread::yield();
|
||||
}
|
||||
if (!equals(load_op(x), new_value)) {
|
||||
y_updated_first.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
});
|
||||
|
||||
t1.join();
|
||||
t2.join();
|
||||
t3.join();
|
||||
t4.join();
|
||||
// thread 3 and thread 4 cannot see different orders of storing x and y
|
||||
assert(!(x_updated_first && y_updated_first));
|
||||
}
|
||||
#else
|
||||
(void)store_op;
|
||||
(void)load_op;
|
||||
#endif
|
||||
}
|
||||
|
||||
// Test that all writes before the store are seen by other threads after the load
|
||||
// Test will pass 100% if store_op and load_op are correctly
|
||||
// affecting the memory with acquire-release order
|
||||
template <class T, class StoreOp, class LoadOp>
|
||||
void test_acquire_release(StoreOp store_op, LoadOp load_op) {
|
||||
#ifndef TEST_HAS_NO_THREADS
|
||||
for (auto i = 0; i < 100; ++i) {
|
||||
T old_value(make_value<T>(0));
|
||||
T new_value(make_value<T>(1));
|
||||
|
||||
T copy = old_value;
|
||||
std::atomic_ref<T> const at(copy);
|
||||
int non_atomic = 5;
|
||||
|
||||
constexpr auto number_of_threads = 8;
|
||||
std::vector<std::thread> threads;
|
||||
threads.reserve(number_of_threads);
|
||||
|
||||
for (auto j = 0; j < number_of_threads; ++j) {
|
||||
threads.push_back(support::make_test_thread([&at, &non_atomic, load_op, new_value] {
|
||||
while (!equals(load_op(at), new_value)) {
|
||||
std::this_thread::yield();
|
||||
}
|
||||
// Other thread's writes before the release store are visible
|
||||
// in this thread's read after the acquire load
|
||||
assert(non_atomic == 6);
|
||||
}));
|
||||
}
|
||||
|
||||
non_atomic = 6;
|
||||
store_op(at, old_value, new_value);
|
||||
|
||||
for (auto& thread : threads) {
|
||||
thread.join();
|
||||
}
|
||||
}
|
||||
#else
|
||||
(void)store_op;
|
||||
(void)load_op;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // TEST_STD_ATOMICS_ATOMIC_REF_TEST_HELPER_H
|
||||
88
libcxx/test/std/atomics/atomics.ref/wait.pass.cpp
Normal file
88
libcxx/test/std/atomics/atomics.ref/wait.pass.cpp
Normal file
@@ -0,0 +1,88 @@
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03, c++11, c++14, c++17
|
||||
// UNSUPPORTED: no-threads
|
||||
// XFAIL: availability-synchronization_library-missing
|
||||
// XFAIL: !has-64-bit-atomics
|
||||
// XFAIL: !has-1024-bit-atomics
|
||||
|
||||
// void wait(T, memory_order = memory_order::seq_cst) const noexcept;
|
||||
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <type_traits>
|
||||
|
||||
#include "atomic_helpers.h"
|
||||
#include "make_test_thread.h"
|
||||
#include "test_helper.h"
|
||||
#include "test_macros.h"
|
||||
|
||||
template <typename T>
|
||||
struct TestWait {
|
||||
void operator()() const {
|
||||
{
|
||||
T x(T(1));
|
||||
std::atomic_ref<T> const a(x);
|
||||
|
||||
assert(a.load() == T(1));
|
||||
a.wait(T(0));
|
||||
std::thread t1 = support::make_test_thread([&]() {
|
||||
a.store(T(3));
|
||||
a.notify_one();
|
||||
});
|
||||
a.wait(T(1));
|
||||
assert(a.load() == T(3));
|
||||
t1.join();
|
||||
ASSERT_NOEXCEPT(a.wait(T(0)));
|
||||
|
||||
assert(a.load() == T(3));
|
||||
a.wait(T(0), std::memory_order_seq_cst);
|
||||
std::thread t2 = support::make_test_thread([&]() {
|
||||
a.store(T(5));
|
||||
a.notify_one();
|
||||
});
|
||||
a.wait(T(3), std::memory_order_seq_cst);
|
||||
assert(a.load() == T(5));
|
||||
t2.join();
|
||||
ASSERT_NOEXCEPT(a.wait(T(0), std::memory_order_seq_cst));
|
||||
}
|
||||
|
||||
// memory_order::acquire
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val, std::memory_order::release); };
|
||||
auto load = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
x.wait(T(255), std::memory_order::acquire);
|
||||
return result;
|
||||
};
|
||||
test_acquire_release<T>(store, load);
|
||||
}
|
||||
|
||||
// memory_order::seq_cst
|
||||
{
|
||||
auto store = [](std::atomic_ref<T> const& x, T, T new_val) { x.store(new_val); };
|
||||
auto load_no_arg = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
x.wait(T(255));
|
||||
return result;
|
||||
};
|
||||
auto load_with_order = [](std::atomic_ref<T> const& x) {
|
||||
auto result = x.load(std::memory_order::relaxed);
|
||||
x.wait(T(255), std::memory_order::seq_cst);
|
||||
return result;
|
||||
};
|
||||
test_seq_cst<T>(store, load_no_arg);
|
||||
test_seq_cst<T>(store, load_with_order);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main(int, char**) {
|
||||
TestEachAtomicType<TestWait>()();
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user