Implement is_always_lock_free

[jfb]

Summary

This was voted into C++17 at last week's 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

[jfb]

include/atomic

840

Moving these from the bottom of the file since I need them.

887

This is slightly ugly, but I don't see a better way to go about without breaking libc++ when it's not exactly in sync with clang, or when it's used with GCC (until GCC picks up these macros).

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

23 ↗

(On Diff #50017)

BOOL and POINTER weren't tested, I'm adding them while I'm here.

[bcraig]

include/atomic

859

Do we need to support configurations were wchar_t is a typedef to an integer type, or is that an abomination too painful to deal with?

I have no idea if the rest of libcxx attempts to deal with wchar_t typedefs.

[jfb]

include/atomic

859

Do you have examples of such platforms? The standard is pretty clear that they're wrong:

[basic.fundamental]

Type wchar_t is a distinct type whose values can represent distinct codes for all members of the largest extended character set specified among the supported locales. Type wchar_t shall have the same size, signedness, and alignment requirements as one of the other integral types, called its *underlying type*.

I'll defer to @mclow.lists on whether we can about such implementations or not.

[EricWF]

include/atomic

849

@mclow.lists I'm fine exposing this typedef retroactively in C++11 and earlier. Do you have any objections to that?

859

I don't think we have to deal with such typedefs for wchar_t but we do have to deal with non-sense typedefs (that we unfortunately supply) for char16_t and char32_t in C++03 mode with GCC.

And our <atomic> implementation needs to compile in C++03 (Sorry, I did that).

[jfb]

include/atomic

849

Which typedef do you mean? Looks like phabricator may have tagged the wrong line.

859

__cpp_lib_atomic_is_always_lock_free takes care of it: it's only defined in C++17 and later so <atomic> should compile just fine.

Is there a test that would catch C++03 breakage?

[EricWF]

include/atomic

849

Sorry I haven't had my coffee yet :-S. I meant the "is_always_lock_free" variable. IDK why I said typedef. However I missed that this is already only exposed in C++17 and beyond. That's even better.

859

Ah I didn't realize that. We have a C++03 bot that will catch any breakage but if your only exposing this in C++17 then we are fine.

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

66 ↗

(On Diff #50017)

This needs to be guarded by #if TEST_STD_VER > 14. The macro lives in test_macros.h.

[EricWF]

@jfb: Actually I changed my mind about guarding the new tests. Can you move the new tests (other than the missing additions) to a new test file? Then add // UNSUPPORTED: c++98, c++03, c++11, c++14 to the top of it?

[bcraig]

Visual Studio has a flag, /Zc:wchar_t-, that turns wchar_t into a short. This flag is for people that need to maintain ABI compatibility with ancient Visual Studios (MSVC6? MSVC5?). It is definitely non-conformant, and many things support it poorly.

I still have nightmares of supporting boost::filesystem users where boost::filesystem was built with real wchar_t, but clients tried to use it with wchar_t as short. The linker generally disapproved of those shenanigans.

I'm totally fine if libcxx doesn't try to support this situation... but if it did want to support it, it would need to selectively not define wchar_t.

[EricWF]

In D17951#376546, @bcraig wrote:

Visual Studio has a flag, /Zc:wchar_t-, that turns wchar_t into a short. This flag is for people that need to maintain ABI compatibility with ancient Visual Studios (MSVC6? MSVC5?). It is definitely non-conformant, and many things support it poorly.

I still have nightmares of supporting boost::filesystem users where boost::filesystem was built with real wchar_t, but clients tried to use it with wchar_t as short. The linker generally disapproved of those shenanigans.

I'm totally fine if libcxx doesn't try to support this situation... but if it did want to support it, it would need to selectively not define wchar_t.

+1 for libcxx not supporting that. I think there are plenty of places where this is already broken in libc++.

[jfb]

In D17951#376546, @bcraig wrote:

Visual Studio has a flag, /Zc:wchar_t-, that turns wchar_t into a short. This flag is for people that need to maintain ABI compatibility with ancient Visual Studios (MSVC6? MSVC5?). It is definitely non-conformant, and many things support it poorly.

I still have nightmares of supporting boost::filesystem users where boost::filesystem was built with real wchar_t, but clients tried to use it with wchar_t as short. The linker generally disapproved of those shenanigans.

I'm totally fine if libcxx doesn't try to support this situation... but if it did want to support it, it would need to selectively not define wchar_t.

That would be pre-C++ standardization (*any* standard) code trying to interact with C++17. I'm inclined to say we shouldn't care ;-)

[jfb]

• Split up tests.

[jfb]

include/atomic

851

Actually, this should be based on sizeof(__a_) and *not* sizeof(_Tp).

[jfb]

• Size is based on __a_ not _Tp
• Check value is consistent with C macros

[jfb]

• Use __atomic_always_lock_free instead

[jfb]

As discussed in now-abandoned D17950 I'll implement everything in libc++. I just have to move the feature test macro to libc++.

[EricWF]

Re-building clang now so I can test the most recent changes.

include/atomic

850

I think this needs a definition.

[jfb]

• Define __cpp_lib_atomic_is_always_lock_free in libc++

[jfb]

include/atomic

850

I don't think so: it's similar to std::integral_constant<_Tp, __v>::value.

[EricWF]

include/atomic

850

integral_constant::value has a definition on line 481 of type_traits.

[jfb]

• Add definition.

include/atomic

850

Ha! I'd totally missed that. That explains why I was confused :-)

Added, thanks!

[EricWF]

LGTM.

[jfb]

• Check feature test macro exists

include/atomic

void
     atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept;
 
 #define ATOMIC_FLAG_INIT see below
 #define ATOMIC_VAR_INIT(value) see below
 
 template <class T>
 struct atomic
 {
+    static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
     void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
     T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
     T load(memory_order m = memory_order_seq_cst) const noexcept;
     operator T() const volatile noexcept;
     operator T() const noexcept;
struct atomic
     atomic& operator=(const atomic&) volatile = delete;
     T operator=(T) volatile noexcept;
     T operator=(T) noexcept;
 };
 
 template <>
 struct atomic<integral>
 {
+    static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;
     void store(integral desr, memory_order m = memory_order_seq_cst) noexcept;
     integral load(memory_order m = memory_order_seq_cst) const volatile noexcept;
     integral load(memory_order m = memory_order_seq_cst) const noexcept;
     operator integral() const volatile noexcept;
     operator integral() const noexcept;
struct atomic<integral>
     integral operator|=(integral op) noexcept;
     integral operator^=(integral op) volatile noexcept;
     integral operator^=(integral op) noexcept;
 };
 
 template <class T>
 struct atomic<T*>
 {
+    static constexpr bool is_always_lock_free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
     void store(T* desr, memory_order m = memory_order_seq_cst) noexcept;
     T* load(memory_order m = memory_order_seq_cst) const volatile noexcept;
     T* load(memory_order m = memory_order_seq_cst) const noexcept;
     operator T*() const volatile noexcept;
     operator T*() const noexcept;

 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 kill_dependency(_Tp __y) _NOEXCEPT
 {
     return __y;
 }
 
+#define ATOMIC_BOOL_LOCK_FREE      __GCC_ATOMIC_BOOL_LOCK_FREE
+#define ATOMIC_CHAR_LOCK_FREE      __GCC_ATOMIC_CHAR_LOCK_FREE
+#define ATOMIC_CHAR16_T_LOCK_FREE  __GCC_ATOMIC_CHAR16_T_LOCK_FREE
+#define ATOMIC_CHAR32_T_LOCK_FREE  __GCC_ATOMIC_CHAR32_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_INT_LOCK_FREE       __GCC_ATOMIC_INT_LOCK_FREE
+#define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE
+#define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
+#define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE
+
 // general atomic<T>
 
 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
 struct __atomic_base  // false
 {
     mutable _Atomic(_Tp) __a_;
 
+#if defined(__cpp_lib_atomic_is_always_lock_free)
+  static _LIBCPP_CONSTEXPR bool is_always_lock_free = __atomic_always_lock_free(sizeof(__a_), 0);
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const volatile _NOEXCEPT
     {
 #if defined(_LIBCPP_HAS_C_ATOMIC_IMP)
     return __c11_atomic_is_lock_free(sizeof(_Tp));
 #else
     return __atomic_is_lock_free(sizeof(_Tp), 0);
 #endif
     }
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const _NOEXCEPT
         {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();}
     _LIBCPP_INLINE_VISIBILITY
     void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
         {__c11_atomic_store(&__a_, __d, __m);}
#endif
     _LIBCPP_INLINE_VISIBILITY
     operator _Tp() const _NOEXCEPT          {return load();}
     _LIBCPP_INLINE_VISIBILITY
     _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
         {return __c11_atomic_exchange(&__a_, __d, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
         {return __c11_atomic_exchange(&__a_, __d, __m);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_weak(_Tp& __e, _Tp __d,
                                memory_order __s, memory_order __f) volatile _NOEXCEPT
         {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_weak(_Tp& __e, _Tp __d,
                                memory_order __s, memory_order __f) _NOEXCEPT
         {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
     _LIBCPP_INLINE_VISIBILITY

 typedef atomic<size_t>    atomic_size_t;
 typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
 typedef atomic<intmax_t>  atomic_intmax_t;
 typedef atomic<uintmax_t> atomic_uintmax_t;
 
 #define ATOMIC_FLAG_INIT {false}
 #define ATOMIC_VAR_INIT(__v) {__v}
 
-#define ATOMIC_BOOL_LOCK_FREE      __GCC_ATOMIC_BOOL_LOCK_FREE
-#define ATOMIC_CHAR_LOCK_FREE      __GCC_ATOMIC_CHAR_LOCK_FREE
-#define ATOMIC_CHAR16_T_LOCK_FREE  __GCC_ATOMIC_CHAR16_T_LOCK_FREE
-#define ATOMIC_CHAR32_T_LOCK_FREE  __GCC_ATOMIC_CHAR32_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_INT_LOCK_FREE       __GCC_ATOMIC_INT_LOCK_FREE
-#define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE
-#define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
-#define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ATOMIC

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

+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+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));
+}