174 lines · cpp
1//===----------------------------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9// UNSUPPORTED: c++03, c++11, c++1410// XFAIL: !has-64-bit-atomics11 12// <atomic>13//14// template <class T>15// class atomic;16//17// static constexpr bool is_always_lock_free;18 19// Ignore diagnostic about vector types changing the ABI on some targets, since20// that is irrelevant for this test.21// ADDITIONAL_COMPILE_FLAGS(gcc-style-warnings): -Wno-psabi22 23#include <atomic>24#include <cassert>25#include <concepts>26#include <cstddef>27 28#include "test_macros.h"29#include "atomic_helpers.h"30 31template <typename T>32void check_always_lock_free(std::atomic<T> const& a) {33 using InfoT = LockFreeStatusInfo<T>;34 35 constexpr auto is_always_lock_free = std::atomic<T>::is_always_lock_free;36 ASSERT_SAME_TYPE(decltype(is_always_lock_free), bool const);37 38 // If we know the status of T for sure, validate the exact result of the function.39 if constexpr (InfoT::status_known) {40 constexpr LockFreeStatus known_status = InfoT::value;41 if constexpr (known_status == LockFreeStatus::always) {42 static_assert(is_always_lock_free, "is_always_lock_free is inconsistent with known lock-free status");43 assert(a.is_lock_free() && "is_lock_free() is inconsistent with known lock-free status");44 } else if constexpr (known_status == LockFreeStatus::never) {45 static_assert(!is_always_lock_free, "is_always_lock_free is inconsistent with known lock-free status");46 assert(!a.is_lock_free() && "is_lock_free() is inconsistent with known lock-free status");47 } else {48 assert(a.is_lock_free() || !a.is_lock_free()); // This is kinda dumb, but we might as well call the function once.49 }50 }51 52 // In all cases, also sanity-check it based on the implication always-lock-free => lock-free.53 if (is_always_lock_free) {54 auto is_lock_free = a.is_lock_free();55 ASSERT_SAME_TYPE(decltype(is_lock_free), bool);56 assert(is_lock_free);57 }58 ASSERT_NOEXCEPT(a.is_lock_free());59}60 61#define CHECK_ALWAYS_LOCK_FREE(T) \62 do { \63 typedef T type; \64 type obj{}; \65 std::atomic<type> a(obj); \66 check_always_lock_free(a); \67 } while (0)68 69void test() {70 char c = 'x';71 check_always_lock_free(std::atomic<char>(c));72 73 int i = 0;74 check_always_lock_free(std::atomic<int>(i));75 76 float f = 0.f;77 check_always_lock_free(std::atomic<float>(f));78 79 int* p = &i;80 check_always_lock_free(std::atomic<int*>(p));81 82 CHECK_ALWAYS_LOCK_FREE(bool);83 CHECK_ALWAYS_LOCK_FREE(char);84 CHECK_ALWAYS_LOCK_FREE(signed char);85 CHECK_ALWAYS_LOCK_FREE(unsigned char);86#if TEST_STD_VER > 17 && defined(__cpp_char8_t)87 CHECK_ALWAYS_LOCK_FREE(char8_t);88#endif89 CHECK_ALWAYS_LOCK_FREE(char16_t);90 CHECK_ALWAYS_LOCK_FREE(char32_t);91 CHECK_ALWAYS_LOCK_FREE(wchar_t);92 CHECK_ALWAYS_LOCK_FREE(short);93 CHECK_ALWAYS_LOCK_FREE(unsigned short);94 CHECK_ALWAYS_LOCK_FREE(int);95 CHECK_ALWAYS_LOCK_FREE(unsigned int);96 CHECK_ALWAYS_LOCK_FREE(long);97 CHECK_ALWAYS_LOCK_FREE(unsigned long);98 CHECK_ALWAYS_LOCK_FREE(long long);99 CHECK_ALWAYS_LOCK_FREE(unsigned long long);100 CHECK_ALWAYS_LOCK_FREE(std::nullptr_t);101 CHECK_ALWAYS_LOCK_FREE(void*);102 CHECK_ALWAYS_LOCK_FREE(float);103 CHECK_ALWAYS_LOCK_FREE(double);104 CHECK_ALWAYS_LOCK_FREE(long double);105#if __has_attribute(vector_size) && defined(_LIBCPP_VERSION)106 CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(1 * sizeof(int)))));107 CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(2 * sizeof(int)))));108 CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(4 * sizeof(int)))));109 CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(16 * sizeof(int)))));110 CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(32 * sizeof(int)))));111 CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(1 * sizeof(float)))));112 CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(2 * sizeof(float)))));113 CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(4 * sizeof(float)))));114 CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(16 * sizeof(float)))));115 CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(32 * sizeof(float)))));116 CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(1 * sizeof(double)))));117 CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(2 * sizeof(double)))));118 CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(4 * sizeof(double)))));119 CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(16 * sizeof(double)))));120 CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(32 * sizeof(double)))));121#endif // __has_attribute(vector_size) && defined(_LIBCPP_VERSION)122 CHECK_ALWAYS_LOCK_FREE(struct Empty{});123 CHECK_ALWAYS_LOCK_FREE(struct OneInt { int i; });124 CHECK_ALWAYS_LOCK_FREE(struct IntArr2 { int i[2]; });125 CHECK_ALWAYS_LOCK_FREE(struct FloatArr3 { float i[3]; });126 CHECK_ALWAYS_LOCK_FREE(struct LLIArr2 { long long int i[2]; });127 CHECK_ALWAYS_LOCK_FREE(struct LLIArr4 { long long int i[4]; });128 CHECK_ALWAYS_LOCK_FREE(struct LLIArr8 { long long int i[8]; });129 CHECK_ALWAYS_LOCK_FREE(struct LLIArr16 { long long int i[16]; });130 CHECK_ALWAYS_LOCK_FREE(struct Padding {131 char c; /* padding */132 long long int i;133 });134 CHECK_ALWAYS_LOCK_FREE(union IntFloat {135 int i;136 float f;137 });138 CHECK_ALWAYS_LOCK_FREE(enum class CharEnumClass : char{foo});139 140 // C macro and static constexpr must be consistent.141 enum class CharEnumClass : char { foo };142 static_assert(std::atomic<bool>::is_always_lock_free == (2 == ATOMIC_BOOL_LOCK_FREE), "");143 static_assert(std::atomic<char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");144 static_assert(std::atomic<CharEnumClass>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");145 static_assert(std::atomic<signed char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");146 static_assert(std::atomic<unsigned char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");147#if TEST_STD_VER > 17 && defined(__cpp_char8_t)148 static_assert(std::atomic<char8_t>::is_always_lock_free == (2 == ATOMIC_CHAR8_T_LOCK_FREE), "");149#endif150 static_assert(std::atomic<char16_t>::is_always_lock_free == (2 == ATOMIC_CHAR16_T_LOCK_FREE), "");151 static_assert(std::atomic<char32_t>::is_always_lock_free == (2 == ATOMIC_CHAR32_T_LOCK_FREE), "");152 static_assert(std::atomic<wchar_t>::is_always_lock_free == (2 == ATOMIC_WCHAR_T_LOCK_FREE), "");153 static_assert(std::atomic<short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE), "");154 static_assert(std::atomic<unsigned short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE), "");155 static_assert(std::atomic<int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE), "");156 static_assert(std::atomic<unsigned int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE), "");157 static_assert(std::atomic<long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE), "");158 static_assert(std::atomic<unsigned long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE), "");159 static_assert(std::atomic<long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE), "");160 static_assert(std::atomic<unsigned long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE), "");161 static_assert(std::atomic<void*>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE), "");162 static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE), "");163 164#if TEST_STD_VER >= 20165 static_assert(std::atomic_signed_lock_free::is_always_lock_free, "");166 static_assert(std::atomic_unsigned_lock_free::is_always_lock_free, "");167#endif168}169 170int main(int, char**) {171 test();172 return 0;173}174