Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Summary: This was voted into C++17 at the Jacksonville meeting. The final P0152R1 paper will be in the upcoming post-Jacksonville mailing, and is also available here: http://jfbastien.github.io/papers/P0152R1.html Reviewers: mclow.lists, rsmith Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D17951 llvm-svn: 264413
- Loading branch information
Showing
2 changed files
with
133 additions
and
11 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
101 changes: 101 additions & 0 deletions
101
libcxx/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,101 @@ | ||
//===----------------------------------------------------------------------===// | ||
// | ||
// The LLVM Compiler Infrastructure | ||
// | ||
// This file is dual licensed under the MIT and the University of Illinois Open | ||
// Source Licenses. See LICENSE.TXT for details. | ||
// | ||
//===----------------------------------------------------------------------===// | ||
// | ||
// UNSUPPORTED: libcpp-has-no-threads, c++98, c++03, c++11, c++14 | ||
|
||
// <atomic> | ||
|
||
// static constexpr bool is_always_lock_free; | ||
|
||
#include <atomic> | ||
#include <cassert> | ||
|
||
#if !defined(__cpp_lib_atomic_is_always_lock_free) | ||
# error Feature test macro missing. | ||
#endif | ||
|
||
template <typename T> void checkAlwaysLockFree() { | ||
if (std::atomic<T>::is_always_lock_free) | ||
assert(std::atomic<T>().is_lock_free()); | ||
} | ||
|
||
int main() | ||
{ | ||
// structs and unions can't be defined in the template invocation. | ||
// Work around this with a typedef. | ||
#define CHECK_ALWAYS_LOCK_FREE(T) \ | ||
do { \ | ||
typedef T type; \ | ||
checkAlwaysLockFree<type>(); \ | ||
} while (0) | ||
|
||
CHECK_ALWAYS_LOCK_FREE(bool); | ||
CHECK_ALWAYS_LOCK_FREE(char); | ||
CHECK_ALWAYS_LOCK_FREE(signed char); | ||
CHECK_ALWAYS_LOCK_FREE(unsigned char); | ||
CHECK_ALWAYS_LOCK_FREE(char16_t); | ||
CHECK_ALWAYS_LOCK_FREE(char32_t); | ||
CHECK_ALWAYS_LOCK_FREE(wchar_t); | ||
CHECK_ALWAYS_LOCK_FREE(short); | ||
CHECK_ALWAYS_LOCK_FREE(unsigned short); | ||
CHECK_ALWAYS_LOCK_FREE(int); | ||
CHECK_ALWAYS_LOCK_FREE(unsigned int); | ||
CHECK_ALWAYS_LOCK_FREE(long); | ||
CHECK_ALWAYS_LOCK_FREE(unsigned long); | ||
CHECK_ALWAYS_LOCK_FREE(long long); | ||
CHECK_ALWAYS_LOCK_FREE(unsigned long long); | ||
CHECK_ALWAYS_LOCK_FREE(std::nullptr_t); | ||
CHECK_ALWAYS_LOCK_FREE(void*); | ||
CHECK_ALWAYS_LOCK_FREE(float); | ||
CHECK_ALWAYS_LOCK_FREE(double); | ||
CHECK_ALWAYS_LOCK_FREE(long double); | ||
CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(1 * sizeof(int))))); | ||
CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(2 * sizeof(int))))); | ||
CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(4 * sizeof(int))))); | ||
CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(16 * sizeof(int))))); | ||
CHECK_ALWAYS_LOCK_FREE(int __attribute__((vector_size(32 * sizeof(int))))); | ||
CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(1 * sizeof(float))))); | ||
CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(2 * sizeof(float))))); | ||
CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(4 * sizeof(float))))); | ||
CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(16 * sizeof(float))))); | ||
CHECK_ALWAYS_LOCK_FREE(float __attribute__((vector_size(32 * sizeof(float))))); | ||
CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(1 * sizeof(double))))); | ||
CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(2 * sizeof(double))))); | ||
CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(4 * sizeof(double))))); | ||
CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(16 * sizeof(double))))); | ||
CHECK_ALWAYS_LOCK_FREE(double __attribute__((vector_size(32 * sizeof(double))))); | ||
CHECK_ALWAYS_LOCK_FREE(struct{}); | ||
CHECK_ALWAYS_LOCK_FREE(struct{ int i; }); | ||
CHECK_ALWAYS_LOCK_FREE(struct{ int i[2]; }); | ||
CHECK_ALWAYS_LOCK_FREE(struct{ long long int i[2]; }); | ||
CHECK_ALWAYS_LOCK_FREE(struct{ long long int i[4]; }); | ||
CHECK_ALWAYS_LOCK_FREE(struct{ long long int i[8]; }); | ||
CHECK_ALWAYS_LOCK_FREE(struct{ long long int i[16]; }); | ||
CHECK_ALWAYS_LOCK_FREE(struct{ char c; /* padding */ long long int i; }); | ||
CHECK_ALWAYS_LOCK_FREE(union{ int i; float f; }); | ||
|
||
// C macro and static constexpr must be consistent. | ||
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<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<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<wchar_t>::is_always_lock_free == (2 == ATOMIC_WCHAR_T_LOCK_FREE)); | ||
static_assert(std::atomic<short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE)); | ||
static_assert(std::atomic<unsigned short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE)); | ||
static_assert(std::atomic<int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE)); | ||
static_assert(std::atomic<unsigned int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE)); | ||
static_assert(std::atomic<long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE)); | ||
static_assert(std::atomic<unsigned long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE)); | ||
static_assert(std::atomic<long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE)); | ||
static_assert(std::atomic<unsigned long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE)); | ||
static_assert(std::atomic<void*>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE)); | ||
static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE)); | ||
} |