Add __atomic_is_lock_free to compiler-rt

[oontvoo]

Summary

This was one of the last required functions missing from Clang's libatomic.

Changes in behaviours:

• On x86-64, it'll now be able to detect and use cmpxchg16b
• The rest should be unchanged, given it'd already been able to figure it out statically.

[oontvoo]

Handled the remaining sizes

[jfb]

This is technically a behavior change, someone like @ldionne ought to chime in, and we probably want to synchronize with libstdc++ @jwakely.

[ldionne]

Can we please get a description of this change in the commit message and the Phab review?

[oontvoo]

updated

[oontvoo]

Removed use of GNU case range extension
(Triggered a bunch of clang-tidys)

[oontvoo]

• Remove the checking of non-power-of-2 sizes from is_lock_free for now (because the atomic_* ops don't handle them yet)
• Rename function to _c and add pragma redefine

[jfb]

Does this x86 change actually match what the runtime does in the same file?

[oontvoo]

Updated diff

[oontvoo]

In D85044#2213896, @jfb wrote:

Does this x86 change actually match what the runtime does in the same file?

Yes

[jfb]

Can you please add tests for this?

compiler-rt/lib/builtins/atomic.c

36

These are OS specific and won't work everywhere.

172

Please document what you're looking up here. It's definitely not "have_cas".

[oontvoo]

Updated diff

[oontvoo]

In D85044#2216023, @jfb wrote:

Can you please add tests for this?

I don't see this file being built anywhere. Can you point me to where to add the test?

[oontvoo]

Simple test

[jyknight]

There is going to be a bunch more complexity required here, I'm afraid.

Not only do we need to detect the CPU capabilities in order to implement atomic_is_lock_free, but we also need to ensure that the implementations of atomic_load_c / etc can actually use those atomic instructions as appropriate.

This means we need to compile the function with different flags, e.g. -mcx16 for x86-64, in order for the compiler to be able to emit cmpxchg16b, or -march=i586 on 32bit x86. But -- we can't compile the entire file that way. Only the functions called after the runtime detection has assured that we're running on the appropriate hardware can be built with those flags.

GCC handles this by compiling the source files multiple times, with different flags, adding some additional #defines which change the function names for each of those compiles. Then, it arranges to dispatch to the correct function depending on the runtime CPU detection. Ideally, we'd also be able to use the "target" attribute to do this on an individual function within the file, but it looks like that may not actually work properly.

compiler-rt/lib/builtins/atomic.c

34

Same check used twice? Also, I think we don't need a configure check for this, #if __has_include(<asm/hwcap.h>) would be ok.

154–156

This isn't threadsafe as written. It would be okay to use a relaxed atomic to load and store __have_atomic_cas (Relaxed is okay, because it's okay to potentially call check_x86_atomic_cas multiple times if this is reached simultaneously on multiple threads, and it will result in the same answer each time).

162–166

It's confusing to have "have_atomic_cas" sometimes mean "have CMPXCHG8b" and sometimes "have CMPXCHG16b".

And that confusion has led to a bug here -- on x86-64, cmpxchg8b is always available, but this code returns false for 8-byte atomics, unless CMPXCHG16b is also available.

177

AArch64 always supports atomics, the HWCAP_ATOMICS is needed only for the newer optimized instructions instead of the older LL/SC loop. (We may want to use those instructions for performance in the future, but it's not necessary for correctness, so we can leave out that complexity for now.

197

Let's leave aside ARM32 support for the first draft and just concentrate on x86 to get the overall framework in place.

202–203

At the end, it'll be better to fail to compile on platforms we haven't implemented, than to do the wrong thing.

But in order to allow implementing platforms piecemeal at the beginning, I'm ok to leave this fallback for now.

229

In C code (compiled with Clang), this can be spelled __attribute__((fallthrough)).

compiler-rt/test/builtins/Unit/atomic_lock_free_test.cc

3

Given that the contract for __atomic_is_lock_free doesn't require actual pointers, I'd leave out the construction of real objects in this test, and just pass in constructed values e.g. (void*)~7.

Also, all these assertions will need to be platform-specific.

[oontvoo]

[WIP] mov stuff to target-specific dirs

[oontvoo]

@jyknight: friendly ping ...

[oontvoo]

rebase.

Note: This has effectively undone D86510 because the patch was trying to avoid _atomic_is_lock_free, which hadn't existed then.

[ldionne]

I'm definitely naive w.r..t compiler-rt, but why is a simple approach like D92302 not sufficient?

[oontvoo]

In D85044#2426999, @ldionne wrote:

I'm definitely naive w.r..t compiler-rt, but why is a simple approach like D92302 not sufficient?

The implementation there provides the *right* answers for the cases that can be determined statically.
There are cases where it can only be determined at runtime.
For eg., unaligned non-power of 2 sizes, or more importantly 16-byte atomic ops can have lock-free implementations on some but not all x86-64 .

Most of the gunk in this patch is to set up for these checks to be extensible.
Eg., for x86/x86-64, we wants to look for CMPXCHG8B/CMPXCHG16B

Then there's the actual making use of CMPXCHG8B/CMPXCHG16B when we know it's available in *_atomic_load/store.

[ldionne]

In D85044#2427077, @oontvoo wrote:

In D85044#2426999, @ldionne wrote:

I'm definitely naive w.r..t compiler-rt, but why is a simple approach like D92302 not sufficient?

The implementation there provides the *right* answers for the cases that can be determined statically.

Doesn't D92302 also check for the alignment of the pointer? My understanding is that with D92302, we're returning true from atomic_is_lock_free whenever the implementation in compiler-rt, as of D92302, would be lockfree. Whether that's the very best we can do on the hardware is a different story -- but D92302's atomic_is_lockfree will be consistent with the actual implementation. Am i mistaken?

So, basically, this patch does the above, but also allows using a lockfree implementation in more cases, is that it? I'm trying to figure out whether it makes sense to land D92302, and then this patch, since this one seems a lot more involved (and still has TODOs). Please let me know if I'm not getting this right, I'm a bit out of my depth trying to read this patch TBH.

[oontvoo]

In D85044#2431334, @ldionne wrote:

Doesn't D92302 also check for the alignment of the pointer? My understanding is that with D92302, we're returning true from atomic_is_lock_free whenever the implementation in compiler-rt, as of D92302, would be lockfree. Whether that's the very best we can do on the hardware is a different story -- but D92302's atomic_is_lockfree will be consistent with the actual implementation. Am i mistaken?

Yes, D92302 provides an implementation of is_lock_free that is consistent with the current _atomic_load_* implementations.
(it's a no change in behaviour)

So, basically, this patch does the above, but also allows using a lockfree implementation in more cases, is that it?

Yes.

I'm trying to figure out whether it makes sense to land D92302, and then this patch, since this one seems a lot more involved (and still has TODOs). Please let me know if I'm not getting this right, I'm a bit out of my depth trying to read this patch TBH.

The two TODOs in this patch was the attempt to simply this so that we have the basic framework in place before filling in more meaty details (ARMs and odd sizes support) . I suspect we'd do those in subsequent patches.

[ldionne]

In D85044#2432266, @oontvoo wrote:

In D85044#2431334, @ldionne wrote:

Doesn't D92302 also check for the alignment of the pointer? My understanding is that with D92302, we're returning true from atomic_is_lock_free whenever the implementation in compiler-rt, as of D92302, would be lockfree. Whether that's the very best we can do on the hardware is a different story -- but D92302's atomic_is_lockfree will be consistent with the actual implementation. Am i mistaken?

Yes, D92302 provides an implementation of is_lock_free that is consistent with the current _atomic_load_* implementations.
(it's a no change in behaviour)

So, basically, this patch does the above, but also allows using a lockfree implementation in more cases, is that it?

Yes.

I'm trying to figure out whether it makes sense to land D92302, and then this patch, since this one seems a lot more involved (and still has TODOs). Please let me know if I'm not getting this right, I'm a bit out of my depth trying to read this patch TBH.

The two TODOs in this patch was the attempt to simply this so that we have the basic framework in place before filling in more meaty details (ARMs and odd sizes support) . I suspect we'd do those in subsequent patches.

Got it, thanks a lot for the clarifications. Unless we're confident that we can move forward with this patch in the near future, I would start by doing D92302 since it solves real problems for libc++ (and Apple platforms to the extent that we're currently shipping a broken compiler-rt). @arichardson There are some tests in this patch, perhaps you could grab them? @oontvoo would you be OK with us trying to land D92302 and then rebasing your patch on top?

[oontvoo]

Yes, sounds good. I don't see why it should wait.

[ldionne]

In D85044#2432326, @oontvoo wrote:

Yes, sounds good. I don't see why it should wait.

Excellent, thank you!

[oontvoo]

updated tests

[oontvoo]

rename aux file to .c

[oontvoo]

(typos)

[arichardson]

compiler-rt/test/builtins/Unit/atomic_lock_free_test.cc

58

This will fail on many 32-bit architectures (e.g. RISC-V 32)

[oontvoo]

addressed comment: restrict size-8 testing to x86-64

[ldionne]

I don't think I'll be able to contribute to this discussion meaningfully without a significant time investment since I don't touch compiler-rt a lot. Since I have a huge review queue in libc++, I'd rather resign from the review than give the impression that it's blocked on me.

compiler-rt/cmake/config-ix.cmake

 check_cxx_compiler_flag(/wd4800 COMPILER_RT_HAS_WD4800_FLAG)
 
 # Symbols.
 check_symbol_exists(__func__ "" COMPILER_RT_HAS_FUNC_SYMBOL)
 
 # Includes.
 check_cxx_compiler_flag(-nostdinc++ COMPILER_RT_HAS_NOSTDINCXX_FLAG)
 check_include_files("sys/auxv.h"    COMPILER_RT_HAS_AUXV)
+check_include_files("asm/hwcap"     COMPILER_RT_HAS_HWCAP)
 
 # Libraries.
 check_library_exists(dl dlopen "" COMPILER_RT_HAS_LIBDL)
 check_library_exists(rt shm_open "" COMPILER_RT_HAS_LIBRT)
 check_library_exists(m pow "" COMPILER_RT_HAS_LIBM)
 check_library_exists(pthread pthread_create "" COMPILER_RT_HAS_LIBPTHREAD)
 check_library_exists(execinfo backtrace "" COMPILER_RT_HAS_LIBEXECINFO)
 

compiler-rt/lib/builtins/atomic.c

 //  always acquired first, to avoid deadlock.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdbool.h>
 #include <stdint.h>
 #include <string.h>
 
+#if defined(__x86_64__) || defined(__i386__)
+#include <cpuid.h>
+#endif
+
+#if defined(COMPILER_RT_HAS_AUXV) && defined(COMPILER_RT_HAS_AUXV)
+#include <asm/hwcap.h>
+#include <sys/auxv.h>
+#endif
+
 #include "assembly.h"
 
 // Clang objects if you redefine a builtin.  This little hack allows us to
 // define a function with the same name as an intrinsic.
 #pragma redefine_extname __atomic_load_c SYMBOL_NAME(__atomic_load)
 #pragma redefine_extname __atomic_store_c SYMBOL_NAME(__atomic_store)
 #pragma redefine_extname __atomic_exchange_c SYMBOL_NAME(__atomic_exchange)
 #pragma redefine_extname __atomic_compare_exchange_c SYMBOL_NAME(              \
     __atomic_compare_exchange)
+#pragma redefine_extname __atomic_is_lock_free_c SYMBOL_NAME(                  \
+    __atomic_is_lock_free)
 
 /// Number of locks.  This allocates one page on 32-bit platforms, two on
 /// 64-bit.  This can be specified externally if a different trade between
 /// memory usage and contention probability is required for a given platform.
 #ifndef SPINLOCK_COUNT
 #define SPINLOCK_COUNT (1 << 10)
 #endif
 static const long SPINLOCK_MASK = SPINLOCK_COUNT - 1;
static __inline Lock *lock_for_pointer(void *ptr) {
   // Now use the high(er) set of bits to perturb the hash, so that we don't
   // get collisions from atomic fields in a single object
   hash >>= 16;
   hash ^= low;
   // Return a pointer to the word to use
   return locks + (hash & SPINLOCK_MASK);
 }
 
-/// Macros for determining whether a size is lock free.  Clang can not yet
-/// codegen __atomic_is_lock_free(16), so for now we assume 16-byte values are
-/// not lock free.
+#if defined(__x86_64__) || defined(__i386__)
+
+#ifdef __x86_64__
+#define FEAT_REG ecx
+#define MASK bit_CMPXCHG16B
+#else
+#define FEAT_REG edx
+#define MASK bit_CMPXCHG8B
+#endif
+
+static inline bool check_x86_atomic_cas(void) {
+  unsigned int eax, ebx, ecx = 0, edx = 0;
+  __get_cpuid(1, &eax, &ebx, &ecx, &edx);
+  return (FEAT_REG & MASK) != 0;
+}
+
+// Returns true if this platform support atomic operation for the given size in
+// bytes.
+static inline bool have_atomic_cap(int N) {
+  static int __have_atomic_cas = -1;
+  if (__have_atomic_cas == -1) {
+    __have_atomic_cas = check_x86_atomic_cas() != 0 ? 1 : 0;
+  }
+  switch (N) {
+  case 1:
+  case 2:
+  case 4:
+    return true;
+  case 8:
+#ifdef __x86_64__
+  case 16:
+#endif
+    return __have_atomic_cas;
+  }
+  return false;
+}
+#elif defined(__aarch64__) && defined(COMPILER_RT_HAS_AUXV) &&                 \
+    defined(COMPILER_RT_HAS_HWCAP)
+// Returns true if this platform support atomic operation for the given size in
+// bytes.
+static inline bool have_atomic_cap(int N) {
+  static int __has_atomic_cap = -1;
+  if (__have_atomic_cap == -1) {
+    __have_atomic_cap = (getauxval(AT_HWCAP) & HWCAP_ATOMICS) != 0 ? 1 : 0;
+  }
+  switch (N) {
+  case 1:
+  case 2:
+  case 4:
+  case 8:
+    return __have_atomic_cap;
+  }
+  return false;
+}
+#elif defined(__arm__)
+// Returns true if this platform support atomic operation for the given size in
+// bytes.
+static inline bool have_atomic_cap(int N) {
+  switch (N) {
+  case 1:
+  case 2:
+  case 4:
+  case 8:
+    return false; // FIXME: not sure the check similar to aarch64 works
+  }
+  return false;
+}
+#else
+// Returns true if this platform support atomic operation for the given size in
+// bytes.
+static inline bool have_atomic_cap(int) { return false; }
+#endif
+
+// Return true if it could  positively be determined to be lock free.
+// Otherwise, fall through to the next bucket (next power-of-2).
+#define CHECK_LOCK_FREE_POW2(N)                                                \
+  do {                                                                         \
+    uintptr_t r = (uintptr_t)ptr & (N - 1);                                    \
+    if (r != 0)                                                                \
+      break;                                                                   \
+    if (__atomic_always_lock_free(N, 0))                                       \
+      return true;                                                             \
+    if (have_atomic_cap(N))                                                    \
+      return true;                                                             \
+  } while (0)
+
+bool __atomic_is_lock_free_c(unsigned long size, const volatile void *ptr) {
+  // FIXME: We don't support non-power-of-2 sizes now. They could be handled
+  // by rounding up to the next power-of-2 bucket. But all the __atomic_*
+  // operations will need to do the same thing as well.
+  switch (size) {
+  case 0:
+    return true;
+  case 2:
+    CHECK_LOCK_FREE_POW2(2);
+    // [[clang::fallthrough]];
+  case 4:
+    CHECK_LOCK_FREE_POW2(4);
+    // [[clang::fallthrough]];
+  case 8:
+    CHECK_LOCK_FREE_POW2(8);
+    // [[clang::fallthrough]];
+  case 16:
+    CHECK_LOCK_FREE_POW2(16);
+    break;
+  }
+  return false;
+}
+
+/// Macros for determining whether a size is lock free.
 #define IS_LOCK_FREE_1 __c11_atomic_is_lock_free(1)
 #define IS_LOCK_FREE_2 __c11_atomic_is_lock_free(2)
 #define IS_LOCK_FREE_4 __c11_atomic_is_lock_free(4)
 #define IS_LOCK_FREE_8 __c11_atomic_is_lock_free(8)
+#ifdef __SIZEOF_INT128__
+#define IS_LOCK_FREE_16 __c11_atomic_is_lock_free(16)
+#define HANDLE_CASE_16                                                         \
+  if (IS_LOCK_FREE_16) {                                                       \
+    LOCK_FREE_ACTION(__uint128_t);                                             \
+  }
+#else
 #define IS_LOCK_FREE_16 0
-
+#define HANDLE_CASE_16
+#endif
 /// Macro that calls the compiler-generated lock-free versions of functions
 /// when they exist.
 #define LOCK_FREE_CASES()                                                      \
   do {                                                                         \
     switch (size) {                                                            \
     case 1:                                                                    \
       if (IS_LOCK_FREE_1) {                                                    \
         LOCK_FREE_ACTION(uint8_t);                                             \
case 4:                                                                    \
       }                                                                        \
       break;                                                                   \
     case 8:                                                                    \
       if (IS_LOCK_FREE_8) {                                                    \
         LOCK_FREE_ACTION(uint64_t);                                            \
       }                                                                        \
       break;                                                                   \
     case 16:                                                                   \
-      if (IS_LOCK_FREE_16) {                                                   \
-        /* FIXME: __uint128_t isn't available on 32 bit platforms.             \
-        LOCK_FREE_ACTION(__uint128_t);*/                                       \
-      }                                                                        \
+      /* Special handling because not all platforms have uint_128*/            \
+      HANDLE_CASE_16                                                           \
       break;                                                                   \
     }                                                                          \
   } while (0)
 
 /// An atomic load operation.  This is atomic with respect to the source
 /// pointer only.
 void __atomic_load_c(int size, void *src, void *dest, int model) {
 #define LOCK_FREE_ACTION(type)                                                 \

compiler-rt/test/builtins/Unit/atomic_lock_free_test.cc

+// RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: librt_has_atomic
+//===-- atomic_lock_free_test.c - Test is_lock_free function         ------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool __atomic_is_lock_free_c(unsigned long size, const volatile void *ptr);
+
+void test_is_lock_free_0(void) {
+  struct A {
+    int a[100];
+  };
+
+  struct A a;
+  // size = 0. Doesn't matter what the aligment is, it should be lock-free.
+  assert(__atomic_is_lock_free_c(0, &a) && "size=0 is not lock free");
+  fprintf(stdout, "test_is_lock_free_0 PASSED\n");
+}
+
+void test_is_lock_free_aligned(void) {
+  // 1
+  char ch = 'a';
+  assert(__atomic_is_lock_free_c(1, &ch) && "size=1 is not lock free");
+
+  // 2
+  short sh __attribute__((aligned(2))) = 2;
+  assert(__atomic_is_lock_free_c(2, &sh) && "size=2 is not lock free");
+
+  struct S2 {
+    char a;
+    char b;
+  } __attribute__((aligned(2)));
+  assert(2 == sizeof(struct S2));
+  struct S2 s2;
+  assert(__atomic_is_lock_free_c(2, &s2) && "size=2 struct is not lock free");
+
+  // 4
+  int i __attribute__((aligned(4))) = 4;
+  assert(__atomic_is_lock_free_c(4, &i) && "size=4 is not lock free");
+
+  struct S4 {
+    short a;
+    short b;
+  } __attribute__((aligned(4)));
+  assert(4 == sizeof(struct S4));
+  struct S4 s4;
+  assert(__atomic_is_lock_free_c(4, &s4) && "size=4 struct is not lock free");
+
+  // 8
+  double d __attribute__((aligned(8))) = 8.0;
+  assert(__atomic_is_lock_free_c(8, &d) && "size=8 is not lock free");
+
+  struct S8 {
+    int a;
+    int b;
+  } __attribute__((aligned(8)));
+  assert(8 == sizeof(struct S8));
+  struct S8 s8;
+  assert(__atomic_is_lock_free_c(8, &s8) && "size=8 struct is not lock free");
+
+#ifdef __SIZEOF_INT128__
+  // 16
+  struct S16 {
+    double a;
+    double b;
+
+  } __attribute__((aligned(16)));
+
+  assert(16 == sizeof(struct S16));
+  struct S16 s16;
+  assert(__atomic_is_lock_free_c(16, &s16) && "size=16 is not lock free");
+#endif
+
+  fprintf(stdout, "test_is_lock_free_aligned PASSED\n");
+}
+
+void test_is_lock_free_unaligned(void) {
+
+  struct S3 {
+    char a;
+    char b;
+    char c;
+  } __attribute__((aligned(1)));
+  assert(3 == sizeof(struct S3));
+  struct S3 s3;
+  assert(!__atomic_is_lock_free_c(3, &s3) && "size=3 struct is lock free");
+
+  struct S34 {
+    char a;
+    char b;
+    char c;
+  } __attribute__((aligned(4)));
+  assert(4 == sizeof(struct S34));
+  struct S34 s34;
+  assert(__atomic_is_lock_free_c(4, &s34) && "size=3, aligned 4 struct is not lock free");
+
+  struct S5 {
+    char a;
+    char b;
+    char c;
+    char d;
+    char e;
+  } __attribute__((aligned(1)));
+  assert(5 == sizeof(struct S5));
+  struct S5 s5;
+  assert(!__atomic_is_lock_free_c(5, &s5) && "size=5 struct is lock free");
+
+  struct S58 {
+    char a;
+    char b;
+    char c;
+    char d;
+    char e;
+  } __attribute__((aligned(8)));
+  assert(8 == sizeof(struct S58));
+  struct S58 s58;
+  assert(__atomic_is_lock_free_c(sizeof(s58), &s58) && "size=5, aligned 8 struct is not lock free");
+
+  struct S9 {
+    char one;
+    char two;
+    char three;
+    char four;
+    char five;
+    char six;
+    char seven;
+    char eight;
+    char nine;
+  } __attribute__((aligned(1)));
+
+  assert(9 == sizeof(struct S9));
+  struct S9 s9;
+  assert(!__atomic_is_lock_free_c(9, &s9) && "size=9 is lock free");
+
+#ifdef __SIZEOF_INT128__
+  struct S9_16 {
+    char one;
+    char two;
+    char three;
+    char four;
+    char five;
+    char six;
+    char seven;
+    char eight;
+    char nine;
+  } __attribute__((aligned(16)));
+
+  assert(16 == sizeof(struct S9_16));
+  struct S9_16 s9_16;
+  assert(__atomic_is_lock_free_c(sizeof(s9_16), &s9) && "size=9, aligned 16 struct  is not lock free");
+#endif
+
+  fprintf(stdout, "test_is_lock_free_unaligned PASSED\n");
+}
+
+int main() {
+  test_is_lock_free_0();
+  test_is_lock_free_aligned();
+  test_is_lock_free_unaligned();
+}

llvm/include/llvm/Config/config.h.cmake

 #ifndef CONFIG_H
 #define CONFIG_H
 
 // Include this header only under the llvm source tree.
 // This is a private header.
 
 /* Exported configuration */
 #include "llvm/Config/llvm-config.h"
 
 /* Bug report URL. */
 #define BUG_REPORT_URL "${BUG_REPORT_URL}"
 
+#cmakedefine COMPILER_RT_HAS_AUXV ${COMPILER_RT_HAS_AUXV}
+#cmakedefine COMPILER_RT_HAS_HWCAP ${COMPILER_RT_HAS_HWCAP}
+
 /* Define to 1 to enable backtraces, and to 0 otherwise. */
 #cmakedefine01 ENABLE_BACKTRACES
 
 /* Define to 1 to enable crash overrides, and to 0 otherwise. */
 #cmakedefine01 ENABLE_CRASH_OVERRIDES
 
 /* Define to 1 to enable crash memory dumps, and to 0 otherwise. */
 #cmakedefine01 LLVM_ENABLE_CRASH_DUMPS