This is an archive of the discontinued LLVM Phabricator instance.

Differential D133377

[libc++] Always query the compiler to find whether a type is always lockfree
ClosedPublic

Authored by ldionne on Sep 6 2022, 2:27 PM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rGf1a601fe88f9: [libc++] Always query the compiler to find whether a type is always lockfree
Summary

In https://llvm.org/D56913, we added an emulation for the __atomic_always_lock_free
compiler builtin when compiling in Freestanding mode. However, the emulation
did (and could not) give exactly the same answer as the compiler builtin,
which led to a potential ABI break for e.g. enum classes.

After speaking to the original author of D56913, we agree that the correct
behavior is to instead always use the compiler builtin, since that provides
a more accurate answer, and __atomic_always_lock_free is a purely front-end
builtin which doesn't require any runtime support. Furthermore, it is
available regardless of the Standard mode (see https://godbolt.org/z/cazf3ssYY).

However, this patch does constitute an ABI break. As shown by https://godbolt.org/z/1eoex6zdK:

  • In LLVM <= 11.0.1, an atomic<enum class with 1 byte> would not contain a lock byte.
  • In LLVM >= 12.0.0, an atomic<enum class with 1 byte> would contain a lock byte.

This patch breaks the ABI again to bring it back to 1 byte, which seems
like the correct thing to do.

Fixes #57440

Diff Detail

Event Timeline

ldionne created this revision.Sep 6 2022, 2:27 PM
Herald added a project: Restricted Project. · View Herald TranscriptSep 6 2022, 2:27 PM
ldionne requested review of this revision.Sep 6 2022, 2:27 PM
Herald added a project: Restricted Project. · View Herald TranscriptSep 6 2022, 2:27 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
ldionne added a subscriber: thieta.Sep 6 2022, 2:29 PM

This is for initial comments. I will figure out a way to test this tomorrow. We'll also need to discuss whether we should cherry-pick to LLVM 15.

I think we should, since we should fix the ABI break as soon as feasible. @thieta Any opinion? FWIW, this only concerns freestanding users, so this is not as widespread as it may seem at first sight.

Harbormaster completed remote builds in B185297: Diff 458280.Sep 6 2022, 3:58 PM
ldionne updated this revision to Diff 458460.Sep 7 2022, 8:13 AM

Add tests.

thieta added a comment.Sep 7 2022, 8:55 AM

When you say freestanding: what does that mean? Ping-pong in the ABI is never great - but if it's not for all users maybe it's worth doing if we think it'll be stable going forward. Do you think it would warrant a 15.1.0 instead of a 15.0.1 in that case?

Harbormaster completed remote builds in B185419: Diff 458460.Sep 7 2022, 9:41 AM
Mordante added a subscriber: Mordante.Sep 8 2022, 9:35 AM

Thanks for picking this up! In general happy with it, but some minor issue.

libcxx/include/atomic
1112

Can you update the release notes for this change.

1409

Can you add a comment why we use the C++17 feature here unconditionally?
This looks like a bug and surely somebody will try to fix it in 5 years time ;-)

ldionne marked an inline comment as done.Sep 15 2022, 10:50 AM
In D133377#3774759, @thieta wrote:

When you say freestanding: what does that mean?

I mean users literally passing the -ffreestanding flag. This is used on embedded platforms, and it's generally a much smaller audience than the mainstream development communities. Not to downplay the importance of it at all, quite the opposite, however in terms of impact this should reach much fewer developers.

Ping-pong in the ABI is never great - but if it's not for all users maybe it's worth doing if we think it'll be stable going forward. Do you think it would warrant a 15.1.0 instead of a 15.0.1 in that case?

Well, I guess the situation is really that we introduced a bug which made our ABI very sub-optimal (i.e. there's a lock in the atomic even when it could be lock free). I think it is definitely worth solving. I don't think it is necessary to do a 15.1.0, I'll just call it out in the release notes.

libcxx/include/atomic
1409

I am not sure why it looks like a bug? I'll add a comment to the definition of __libcpp_is_always_lock_free explaining that the compiler builtin we're using there is available in all versions.

ldionne updated this revision to Diff 460458.Sep 15 2022, 10:50 AM
ldionne marked 2 inline comments as done.

Address comments.

Harbormaster completed remote builds in B186901: Diff 460458.Sep 15 2022, 1:46 PM
ldionne accepted this revision.Sep 19 2022, 8:09 AM
This revision is now accepted and ready to land.Sep 19 2022, 8:09 AM
Closed by commit rGf1a601fe88f9: [libc++] Always query the compiler to find whether a type is always lockfree (authored by ldionne). · Explain WhySep 19 2022, 8:10 AM
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rGf1a601fe88f9: [libc++] Always query the compiler to find whether a type is always lockfree.
ldionne mentioned this in D142285: [libc++] Don't include <version> everywhere.Jan 26 2023, 9:00 AM

Revision Contents

PathSize
libcxx/
docs/
8 lines
include/
46 lines
test/
libcxx/
atomics/
atomics.align/
1 line
std/
atomics/
atomics.lockfree/
14 lines

Diff 461215

libcxx/docs/ReleaseNotes.rst

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines- The comparison operators on ``thread::id`` are now defined as free-standing
Also see `issue 56187 <https://github.com/llvm/llvm-project/issues/56187>`_. Also see `issue 56187 <https://github.com/llvm/llvm-project/issues/56187>`_.
- ``_LIBCPP_ENABLE_NODISCARD`` and ``_LIBCPP_DISABLE_NODISCARD_AFTER_CXX17`` are no longer respected. - ``_LIBCPP_ENABLE_NODISCARD`` and ``_LIBCPP_DISABLE_NODISCARD_AFTER_CXX17`` are no longer respected.
Any standards-required ``[[nodiscard]]`` applications in C++20 are now always enabled. Any extended applications Any standards-required ``[[nodiscard]]`` applications in C++20 are now always enabled. Any extended applications
are now enabled by default and can be disabled by defining ``_LIBCPP_DISABLE_NODISCARD_EXT``. are now enabled by default and can be disabled by defining ``_LIBCPP_DISABLE_NODISCARD_EXT``.
ABI Affecting Changes ABI Affecting Changes
--------------------- ---------------------
- In freestanding mode, ``atomic<small enum class>`` does not contain a lock byte anymore if the platform
can implement lockfree atomics for that size. More specifically, in LLVM <= 11.0.1, an ``atomic<small enum class>``
would not contain a lock byte. This was broken in LLVM >= 12.0.0, where it started including a lock byte despite
the platform supporting lockfree atomics for that size. Starting in LLVM 15.0.1, the ABI for these types has been
restored to what it used to be (no lock byte), which is the most efficient implementation.
This ABI break only affects users that compile with ``-ffreestanding``, and only for ``atomic<T>`` where ``T``
is a non-builtin type that could be lockfree on the platform. See https://llvm.org/D133377 for more details.
Build System Changes Build System Changes
-------------------- --------------------

libcxx/include/atomic

Show First 20 Lines • Show All 1,103 Lines • ▼ Show 20 Lines
# define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE # define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
# define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE # define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
# define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE # define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
# define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE # define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
# define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE # define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
# define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE # define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
#endif #endif
template <class _Tp>
MordanteUnsubmitted
Done
ReplyInline Actions

Can you update the release notes for this change.

Mordante: Can you update the release notes for this change.
struct __libcpp_is_always_lock_free {
// __atomic_always_lock_free is available in all Standard modes
static const bool __value = __atomic_always_lock_free(sizeof(_Tp), 0);
};
#ifdef _LIBCPP_ATOMIC_ONLY_USE_BUILTINS #ifdef _LIBCPP_ATOMIC_ONLY_USE_BUILTINS
template<typename _Tp> template<typename _Tp>
struct __cxx_atomic_lock_impl { struct __cxx_atomic_lock_impl {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__cxx_atomic_lock_impl() _NOEXCEPT __cxx_atomic_lock_impl() _NOEXCEPT
: __a_value(), __a_lock(0) {} : __a_value(), __a_lock(0) {}
▲ Show 20 Lines • Show All 275 Lines • ▼ Show 20 Lines_Tp __cxx_atomic_fetch_xor(__cxx_atomic_lock_impl<_Tp>* __a,
_Tp __pattern, memory_order) { _Tp __pattern, memory_order) {
__a->__lock(); __a->__lock();
_Tp __old = __a->__a_value; _Tp __old = __a->__a_value;
__a->__a_value ^= __pattern; __a->__a_value ^= __pattern;
__a->__unlock(); __a->__unlock();
return __old; return __old;
} }
#ifdef __cpp_lib_atomic_is_always_lock_free
template<typename _Tp> struct __cxx_is_always_lock_free {
enum { __value = __atomic_always_lock_free(sizeof(_Tp), 0) }; };
#else
template<typename _Tp> struct __cxx_is_always_lock_free { enum { __value = false }; };
// Implementations must match the C ATOMIC_*_LOCK_FREE macro values.
template<> struct __cxx_is_always_lock_free<bool> { enum { __value = 2 == ATOMIC_BOOL_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<signed char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<unsigned char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
#ifndef _LIBCPP_HAS_NO_CHAR8_T
template<> struct __cxx_is_always_lock_free<char8_t> { enum { __value = 2 == ATOMIC_CHAR8_T_LOCK_FREE }; };
#endif
template<> struct __cxx_is_always_lock_free<char16_t> { enum { __value = 2 == ATOMIC_CHAR16_T_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<char32_t> { enum { __value = 2 == ATOMIC_CHAR32_T_LOCK_FREE }; };
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template<> struct __cxx_is_always_lock_free<wchar_t> { enum { __value = 2 == ATOMIC_WCHAR_T_LOCK_FREE }; };
#endif
template<> struct __cxx_is_always_lock_free<short> { enum { __value = 2 == ATOMIC_SHORT_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<unsigned short> { enum { __value = 2 == ATOMIC_SHORT_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<int> { enum { __value = 2 == ATOMIC_INT_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<unsigned int> { enum { __value = 2 == ATOMIC_INT_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<long> { enum { __value = 2 == ATOMIC_LONG_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<unsigned long> { enum { __value = 2 == ATOMIC_LONG_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<long long> { enum { __value = 2 == ATOMIC_LLONG_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<unsigned long long> { enum { __value = 2 == ATOMIC_LLONG_LOCK_FREE }; };
template<typename _Tp> struct __cxx_is_always_lock_free<_Tp*> { enum { __value = 2 == ATOMIC_POINTER_LOCK_FREE }; };
template<> struct __cxx_is_always_lock_free<std::nullptr_t> { enum { __value = 2 == ATOMIC_POINTER_LOCK_FREE }; };
#endif //__cpp_lib_atomic_is_always_lock_free
template <typename _Tp, template <typename _Tp,
MordanteUnsubmitted
Done
ReplyInline Actions

Can you add a comment why we use the C++17 feature here unconditionally?
This looks like a bug and surely somebody will try to fix it in 5 years time ;-)

Mordante: Can you add a comment why we use the C++17 feature here unconditionally? This looks like a bug…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

I am not sure why it looks like a bug? I'll add a comment to the definition of __libcpp_is_always_lock_free explaining that the compiler builtin we're using there is available in all versions.

ldionne: I am not sure why it looks like a bug? I'll add a comment to the definition of…
typename _Base = typename conditional<__cxx_is_always_lock_free<_Tp>::__value, typename _Base = typename conditional<__libcpp_is_always_lock_free<_Tp>::__value,
__cxx_atomic_base_impl<_Tp>, __cxx_atomic_base_impl<_Tp>,
__cxx_atomic_lock_impl<_Tp> >::type> __cxx_atomic_lock_impl<_Tp> >::type>
#else #else
template <typename _Tp, template <typename _Tp,
typename _Base = __cxx_atomic_base_impl<_Tp> > typename _Base = __cxx_atomic_base_impl<_Tp> >
#endif //_LIBCPP_ATOMIC_ONLY_USE_BUILTINS #endif //_LIBCPP_ATOMIC_ONLY_USE_BUILTINS
struct __cxx_atomic_impl : public _Base { struct __cxx_atomic_impl : public _Base {
static_assert(is_trivially_copyable<_Tp>::value, static_assert(is_trivially_copyable<_Tp>::value,
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
// general atomic<T> // general atomic<T>
template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value> template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
struct __atomic_base // false struct __atomic_base // false
{ {
mutable __cxx_atomic_impl<_Tp> __a_; mutable __cxx_atomic_impl<_Tp> __a_;
#if defined(__cpp_lib_atomic_is_always_lock_free) #if defined(__cpp_lib_atomic_is_always_lock_free)
static _LIBCPP_CONSTEXPR bool is_always_lock_free = __atomic_always_lock_free(sizeof(__a_), 0); static _LIBCPP_CONSTEXPR bool is_always_lock_free = __libcpp_is_always_lock_free<__cxx_atomic_impl<_Tp> >::__value;
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool is_lock_free() const volatile _NOEXCEPT bool is_lock_free() const volatile _NOEXCEPT
{return __cxx_atomic_is_lock_free(sizeof(_Tp));} {return __cxx_atomic_is_lock_free(sizeof(_Tp));}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool is_lock_free() const _NOEXCEPT bool is_lock_free() const _NOEXCEPT
{return static_cast<__atomic_base const volatile*>(this)->is_lock_free();} {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();}
▲ Show 20 Lines • Show All 1,086 Lines • ▼ Show 20 Lines
typedef atomic<size_t> atomic_size_t; typedef atomic<size_t> atomic_size_t;
typedef atomic<ptrdiff_t> atomic_ptrdiff_t; typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
typedef atomic<intmax_t> atomic_intmax_t; typedef atomic<intmax_t> atomic_intmax_t;
typedef atomic<uintmax_t> atomic_uintmax_t; typedef atomic<uintmax_t> atomic_uintmax_t;
// atomic_*_lock_free : prefer the contention type most highly, then the largest lock-free type // atomic_*_lock_free : prefer the contention type most highly, then the largest lock-free type
#ifdef __cpp_lib_atomic_is_always_lock_free #ifdef __cpp_lib_atomic_is_always_lock_free
# define _LIBCPP_CONTENTION_LOCK_FREE __atomic_always_lock_free(sizeof(__cxx_contention_t), 0) # define _LIBCPP_CONTENTION_LOCK_FREE ::std::__libcpp_is_always_lock_free<__cxx_contention_t>::__value
#else #else
# define _LIBCPP_CONTENTION_LOCK_FREE false # define _LIBCPP_CONTENTION_LOCK_FREE false
#endif #endif
#if ATOMIC_LLONG_LOCK_FREE == 2 #if ATOMIC_LLONG_LOCK_FREE == 2
typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, long long>::type __libcpp_signed_lock_free; typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, long long>::type __libcpp_signed_lock_free;
typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned long long>::type __libcpp_unsigned_lock_free; typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned long long>::type __libcpp_unsigned_lock_free;
#elif ATOMIC_INT_LOCK_FREE == 2 #elif ATOMIC_INT_LOCK_FREE == 2
Show All 39 Lines

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines#endif
CHECK_ALIGNMENT(struct OneInt { int i; }); CHECK_ALIGNMENT(struct OneInt { int i; });
CHECK_ALIGNMENT(struct IntArr2 { int i[2]; }); CHECK_ALIGNMENT(struct IntArr2 { int i[2]; });
CHECK_ALIGNMENT(struct LLIArr2 { long long int i[2]; }); CHECK_ALIGNMENT(struct LLIArr2 { long long int i[2]; });
CHECK_ALIGNMENT(struct LLIArr4 { long long int i[4]; }); CHECK_ALIGNMENT(struct LLIArr4 { long long int i[4]; });
CHECK_ALIGNMENT(struct LLIArr8 { long long int i[8]; }); CHECK_ALIGNMENT(struct LLIArr8 { long long int i[8]; });
CHECK_ALIGNMENT(struct LLIArr16 { long long int i[16]; }); CHECK_ALIGNMENT(struct LLIArr16 { long long int i[16]; });
CHECK_ALIGNMENT(struct Padding { char c; /* padding */ long long int i; }); CHECK_ALIGNMENT(struct Padding { char c; /* padding */ long long int i; });
CHECK_ALIGNMENT(union IntFloat { int i; float f; }); CHECK_ALIGNMENT(union IntFloat { int i; float f; });
CHECK_ALIGNMENT(enum class StrongEnum { foo });
return 0; return 0;
} }

libcxx/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp

Show All 11 Lines
// static constexpr bool is_always_lock_free; // static constexpr bool is_always_lock_free;
#include <atomic> #include <atomic>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if !defined(__cpp_lib_atomic_is_always_lock_free) template <typename T>
# error Feature test macro missing. void checkAlwaysLockFree() {
#endif if (std::atomic<T>::is_always_lock_free) {
LIBCPP_ASSERT(sizeof(std::atomic<T>) == sizeof(T)); // technically not required, but libc++ does it that way
template <typename T> void checkAlwaysLockFree() {
if (std::atomic<T>::is_always_lock_free)
assert(std::atomic<T>().is_lock_free()); assert(std::atomic<T>().is_lock_free());
} }
}
void run() void run()
{ {
// structs and unions can't be defined in the template invocation. // structs and unions can't be defined in the template invocation.
// Work around this with a typedef. // Work around this with a typedef.
#define CHECK_ALWAYS_LOCK_FREE(T) \ #define CHECK_ALWAYS_LOCK_FREE(T) \
do { \ do { \
typedef T type; \ typedef T type; \
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines#endif // __has_attribute(vector_size) && defined(_LIBCPP_VERSION)
CHECK_ALWAYS_LOCK_FREE(struct OneInt { int i; }); CHECK_ALWAYS_LOCK_FREE(struct OneInt { int i; });
CHECK_ALWAYS_LOCK_FREE(struct IntArr2 { int i[2]; }); CHECK_ALWAYS_LOCK_FREE(struct IntArr2 { int i[2]; });
CHECK_ALWAYS_LOCK_FREE(struct LLIArr2 { long long int i[2]; }); 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 LLIArr4 { long long int i[4]; });
CHECK_ALWAYS_LOCK_FREE(struct LLIArr8 { long long int i[8]; }); 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 LLIArr16 { long long int i[16]; });
CHECK_ALWAYS_LOCK_FREE(struct Padding { char c; /* padding */ long long int i; }); 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(union IntFloat { int i; float f; });
CHECK_ALWAYS_LOCK_FREE(enum class CharEnumClass : char { foo });
// C macro and static constexpr must be consistent. // C macro and static constexpr must be consistent.
enum class CharEnumClass : char { foo };
static_assert(std::atomic<bool>::is_always_lock_free == (2 == ATOMIC_BOOL_LOCK_FREE), ""); static_assert(std::atomic<bool>::is_always_lock_free == (2 == ATOMIC_BOOL_LOCK_FREE), "");
static_assert(std::atomic<char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), ""); static_assert(std::atomic<char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
static_assert(std::atomic<CharEnumClass>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
static_assert(std::atomic<signed char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), ""); static_assert(std::atomic<signed char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
static_assert(std::atomic<unsigned char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), ""); static_assert(std::atomic<unsigned char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
#if TEST_STD_VER > 17 && defined(__cpp_char8_t) #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
static_assert(std::atomic<char8_t>::is_always_lock_free == (2 == ATOMIC_CHAR8_T_LOCK_FREE), ""); static_assert(std::atomic<char8_t>::is_always_lock_free == (2 == ATOMIC_CHAR8_T_LOCK_FREE), "");
#endif #endif
static_assert(std::atomic<char16_t>::is_always_lock_free == (2 == ATOMIC_CHAR16_T_LOCK_FREE), ""); static_assert(std::atomic<char16_t>::is_always_lock_free == (2 == ATOMIC_CHAR16_T_LOCK_FREE), "");
static_assert(std::atomic<char32_t>::is_always_lock_free == (2 == ATOMIC_CHAR32_T_LOCK_FREE), ""); static_assert(std::atomic<char32_t>::is_always_lock_free == (2 == ATOMIC_CHAR32_T_LOCK_FREE), "");
static_assert(std::atomic<wchar_t>::is_always_lock_free == (2 == ATOMIC_WCHAR_T_LOCK_FREE), ""); static_assert(std::atomic<wchar_t>::is_always_lock_free == (2 == ATOMIC_WCHAR_T_LOCK_FREE), "");
Show All 18 Lines