[OpenMP] libomp: add atomic functions for new OpenMP 5.1 atomics.

[AndreyChurbanov]

Summary

Added functions those implement "atomic compare".
Though clang does not use library interfaces to implement OpenMP atomics,
the functions added for consistency.

Also added missed functions for 80-bit floating min/max atomics.

[tlwilmar]

LGTM

[kkwli0]

Is this patch only applicable to KMP_ARCH_X86 || KMP_ARCH_X86_64 arch? The newly added test cases fail on non-X86 platform due to undefined symbols. The __kmpc_atomic_*_cas_* prototypes got preprocessed out inside the extern "C" hence the names are mangled.

[protze.joachim]

Why are the types in __kmpc_atomic_val_4_cas_cpt different from the types in __kmpc_atomic_val_4_cas? I think, all the functions should use fixed-size integer to respect the width suggested by the name of the function.

[AndreyChurbanov]

In D110109#3077855, @kkwli0 wrote:

Is this patch only applicable to KMP_ARCH_X86 || KMP_ARCH_X86_64 arch? The newly added test cases fail on non-X86 platform due to undefined symbols. The __kmpc_atomic_*_cas_* prototypes got preprocessed out inside the extern "C" hence the names are mangled.

Thanks for comment. The implementation is indeed supposed to be applicable to KMP_ARCH_X86 || KMP_ARCH_X86_64 only.
I've fixed the tests in commit https://reviews.llvm.org/rG52f4922ebb7b. Library code fixed in https://reviews.llvm.org/D112261 to eliminate mangled symbols from the build on non-x86 architectures.

[AndreyChurbanov]

In D110109#3077907, @protze.joachim wrote:

Why are the types in __kmpc_atomic_val_4_cas_cpt different from the types in __kmpc_atomic_val_4_cas? I think, all the functions should use fixed-size integer to respect the width suggested by the name of the function.

Sorry, Joachim, I haven't got your comment. Both functions deal with kmp_int32 that is 4 bytes. Or am I missing something?

[kkwli0]

@AndreyChurbanov There is one more issue. kmp_atomic_float10_max_min.c specifies -mlong-double-80 but some platforms (e.g. Power) do not support such option.

[AndreyChurbanov]

In D110109#3089150, @kkwli0 wrote:

@AndreyChurbanov There is one more issue. kmp_atomic_float10_max_min.c specifies -mlong-double-80 but some platforms (e.g. Power) do not support such option.

Thanks for reporting.
I've added "UNSUPPORTED: powerpc" to the test in git commit 6f0125eec75f, hope it fixes the problem.

openmp/runtime/src/dllexports

#__kmpc_atomic_8                    # declared above #101
     __kmpc_atomic_fixed4u_add_fp
     __kmpc_atomic_fixed4u_sub_fp
     __kmpc_atomic_fixed4u_mul_fp
     __kmpc_atomic_fixed8u_add_fp
     __kmpc_atomic_fixed8u_sub_fp
     __kmpc_atomic_fixed8u_mul_fp
     %endif
 
+    # OpenMP 5.1 atomics
+    __kmpc_atomic_float10_max              2139
+    __kmpc_atomic_float10_min              2140
+    __kmpc_atomic_float10_max_cpt          2141
+    __kmpc_atomic_float10_min_cpt          2142
+
+    __kmpc_atomic_bool_1_cas               2143
+    __kmpc_atomic_bool_2_cas               2144
+    __kmpc_atomic_bool_4_cas               2145
+    __kmpc_atomic_bool_8_cas               2146
+    __kmpc_atomic_val_1_cas                2147
+    __kmpc_atomic_val_2_cas                2148
+    __kmpc_atomic_val_4_cas                2149
+    __kmpc_atomic_val_8_cas                2150
+    __kmpc_atomic_bool_1_cas_cpt           2151
+    __kmpc_atomic_bool_2_cas_cpt           2152
+    __kmpc_atomic_bool_4_cas_cpt           2153
+    __kmpc_atomic_bool_8_cas_cpt           2154
+    __kmpc_atomic_val_1_cas_cpt            2155
+    __kmpc_atomic_val_2_cas_cpt            2156
+    __kmpc_atomic_val_4_cas_cpt            2157
+    __kmpc_atomic_val_8_cas_cpt            2158
+
 %endif
 
 # end of file #

openmp/runtime/src/kmp_atomic.h

 void __kmpc_atomic_float4_max(ident_t *id_ref, int gtid, kmp_real32 *lhs,
                               kmp_real32 rhs);
 void __kmpc_atomic_float4_min(ident_t *id_ref, int gtid, kmp_real32 *lhs,
                               kmp_real32 rhs);
 void __kmpc_atomic_float8_max(ident_t *id_ref, int gtid, kmp_real64 *lhs,
                               kmp_real64 rhs);
 void __kmpc_atomic_float8_min(ident_t *id_ref, int gtid, kmp_real64 *lhs,
                               kmp_real64 rhs);
+void __kmpc_atomic_float10_max(ident_t *id_ref, int gtid, long double *lhs,
+                               long double rhs);
+void __kmpc_atomic_float10_min(ident_t *id_ref, int gtid, long double *lhs,
+                               long double rhs);
 #if KMP_HAVE_QUAD
 void __kmpc_atomic_float16_max(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
                                QUAD_LEGACY rhs);
 void __kmpc_atomic_float16_min(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
                                QUAD_LEGACY rhs);
 #if (KMP_ARCH_X86)
 // Routines with 16-byte arguments aligned to 16-byte boundary; IA-32
 // architecture only
kmp_real32 __kmpc_atomic_float4_min_cpt(ident_t *id_ref, int gtid,
                                         kmp_real32 *lhs, kmp_real32 rhs,
                                         int flag);
 kmp_real64 __kmpc_atomic_float8_max_cpt(ident_t *id_ref, int gtid,
                                         kmp_real64 *lhs, kmp_real64 rhs,
                                         int flag);
 kmp_real64 __kmpc_atomic_float8_min_cpt(ident_t *id_ref, int gtid,
                                         kmp_real64 *lhs, kmp_real64 rhs,
                                         int flag);
+long double __kmpc_atomic_float10_max_cpt(ident_t *id_ref, int gtid,
+                                          long double *lhs, long double rhs,
+                                          int flag);
+long double __kmpc_atomic_float10_min_cpt(ident_t *id_ref, int gtid,
+                                          long double *lhs, long double rhs,
+                                          int flag);
 #if KMP_HAVE_QUAD
 QUAD_LEGACY __kmpc_atomic_float16_max_cpt(ident_t *id_ref, int gtid,
                                           QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
                                           int flag);
 QUAD_LEGACY __kmpc_atomic_float16_min_cpt(ident_t *id_ref, int gtid,
                                           QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
                                           int flag);
 #endif

 long double __kmpc_atomic_float10_div_cpt_rev_fp(ident_t *id_ref, int gtid,
                                                  long double *lhs, _Quad rhs,
                                                  int flag);
 
 #endif // KMP_HAVE_QUAD
 
 // End of OpenMP 4.0 capture
 
+// OpenMP 5.1 compare and swap
+/*
+    __kmpc_atomic_bool_1_cas
+    __kmpc_atomic_bool_2_cas
+    __kmpc_atomic_bool_4_cas
+    __kmpc_atomic_bool_8_cas
+    __kmpc_atomic_val_1_cas
+    __kmpc_atomic_val_2_cas
+    __kmpc_atomic_val_4_cas
+    __kmpc_atomic_val_8_cas
+    __kmpc_atomic_bool_1_cas_cpt
+    __kmpc_atomic_bool_2_cas_cpt
+    __kmpc_atomic_bool_4_cas_cpt
+    __kmpc_atomic_bool_8_cas_cpt
+    __kmpc_atomic_val_1_cas_cpt
+    __kmpc_atomic_val_2_cas_cpt
+    __kmpc_atomic_val_4_cas_cpt
+    __kmpc_atomic_val_8_cas_cpt
+*/
+// In all interfaces of CAS (Compare And Swap):
+// r is the boolean result of comparison
+// x is memory location to operate on
+// e is expected (old) value
+// d is desired (new) value
+// pv is pointer to captured value v whose location may coincide with e
+
+// { r = x == e; if(r) { x = d; } }
+// functions return result of comparison
+bool __kmpc_atomic_bool_1_cas(ident_t *loc, int gtid, char *x, char e, char d);
+bool __kmpc_atomic_bool_2_cas(ident_t *loc, int gtid, short *x, short e,
+                              short d);
+bool __kmpc_atomic_bool_4_cas(ident_t *loc, int gtid, kmp_int32 *x, kmp_int32 e,
+                              kmp_int32 d);
+bool __kmpc_atomic_bool_8_cas(ident_t *loc, int gtid, kmp_int64 *x, kmp_int64 e,
+                              kmp_int64 d);
+
+// { v = x; if (x == e) { x = d; } }
+// functions return old value
+char __kmpc_atomic_val_1_cas(ident_t *loc, int gtid, char *x, char e, char d);
+short __kmpc_atomic_val_2_cas(ident_t *loc, int gtid, short *x, short e,
+                              short d);
+kmp_int32 __kmpc_atomic_val_4_cas(ident_t *loc, int gtid, kmp_int32 *x,
+                                  kmp_int32 e, kmp_int32 d);
+kmp_int64 __kmpc_atomic_val_8_cas(ident_t *loc, int gtid, kmp_int64 *x,
+                                  kmp_int64 e, kmp_int64 d);
+
+// { r = x == e; if(r) { x = d; } else { v = x; } }
+// v gets old value if comparison failed, untouched otherwise
+// functions return result of comparison
+bool __kmpc_atomic_bool_1_cas_cpt(ident_t *loc, int gtid, char *x, char e,
+                                  char d, char *pv);
+bool __kmpc_atomic_bool_2_cas_cpt(ident_t *loc, int gtid, short *x, short e,
+                                  short d, short *pv);
+bool __kmpc_atomic_bool_4_cas_cpt(ident_t *loc, int gtid, kmp_int32 *x,
+                                  kmp_int32 e, kmp_int32 d, kmp_int32 *pv);
+bool __kmpc_atomic_bool_8_cas_cpt(ident_t *loc, int gtid, kmp_int64 *x,
+                                  kmp_int64 e, kmp_int64 d, kmp_int64 *pv);
+
+// { if (x == e) { x = d; }; v = x; }
+// v gets old value if comparison failed, new value otherwise
+// functions return old value
+char __kmpc_atomic_val_1_cas_cpt(ident_t *loc, int gtid, char *x, char e,
+                                 char d, char *pv);
+short __kmpc_atomic_val_2_cas_cpt(ident_t *loc, int gtid, short *x, short e,
+                                  short d, short *pv);
+kmp_int32 __kmpc_atomic_val_4_cas_cpt(ident_t *loc, int gtid, kmp_int32 *x,
+                                      kmp_int32 e, kmp_int32 d, kmp_int32 *pv);
+kmp_int64 __kmpc_atomic_val_8_cas_cpt(ident_t *loc, int gtid, kmp_int64 *x,
+                                      kmp_int64 e, kmp_int64 d, kmp_int64 *pv);
+
+// End OpenMP 5.1 compare + capture
+
 #endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
 
 /* ------------------------------------------------------------------------ */
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
 #endif /* KMP_ATOMIC_H */
 
 // end of file

openmp/runtime/src/kmp_atomic.cpp

 MIN_MAX_COMPXCHG(float4, max, kmp_real32, 32, <, 4r, 3,
                  KMP_ARCH_X86) // __kmpc_atomic_float4_max
 MIN_MAX_COMPXCHG(float4, min, kmp_real32, 32, >, 4r, 3,
                  KMP_ARCH_X86) // __kmpc_atomic_float4_min
 MIN_MAX_COMPXCHG(float8, max, kmp_real64, 64, <, 8r, 7,
                  KMP_ARCH_X86) // __kmpc_atomic_float8_max
 MIN_MAX_COMPXCHG(float8, min, kmp_real64, 64, >, 8r, 7,
                  KMP_ARCH_X86) // __kmpc_atomic_float8_min
+MIN_MAX_CRITICAL(float10, max, long double, <, 10r,
+                 1) // __kmpc_atomic_float10_max
+MIN_MAX_CRITICAL(float10, min, long double, >, 10r,
+                 1) // __kmpc_atomic_float10_min
 #if KMP_HAVE_QUAD
 MIN_MAX_CRITICAL(float16, max, QUAD_LEGACY, <, 16r,
                  1) // __kmpc_atomic_float16_max
 MIN_MAX_CRITICAL(float16, min, QUAD_LEGACY, >, 16r,
                  1) // __kmpc_atomic_float16_min
 #if (KMP_ARCH_X86)
 MIN_MAX_CRITICAL(float16, max_a16, Quad_a16_t, <, 16r,
                  1) // __kmpc_atomic_float16_max_a16

 MIN_MAX_COMPXCHG_CPT(float4, max_cpt, kmp_real32, 32, <,
                      KMP_ARCH_X86) // __kmpc_atomic_float4_max_cpt
 MIN_MAX_COMPXCHG_CPT(float4, min_cpt, kmp_real32, 32, >,
                      KMP_ARCH_X86) // __kmpc_atomic_float4_min_cpt
 MIN_MAX_COMPXCHG_CPT(float8, max_cpt, kmp_real64, 64, <,
                      KMP_ARCH_X86) // __kmpc_atomic_float8_max_cpt
 MIN_MAX_COMPXCHG_CPT(float8, min_cpt, kmp_real64, 64, >,
                      KMP_ARCH_X86) // __kmpc_atomic_float8_min_cpt
+MIN_MAX_CRITICAL_CPT(float10, max_cpt, long double, <, 10r,
+                     1) // __kmpc_atomic_float10_max_cpt
+MIN_MAX_CRITICAL_CPT(float10, min_cpt, long double, >, 10r,
+                     1) // __kmpc_atomic_float10_min_cpt
 #if KMP_HAVE_QUAD
 MIN_MAX_CRITICAL_CPT(float16, max_cpt, QUAD_LEGACY, <, 16r,
                      1) // __kmpc_atomic_float16_max_cpt
 MIN_MAX_CRITICAL_CPT(float16, min_cpt, QUAD_LEGACY, >, 16r,
                      1) // __kmpc_atomic_float16_min_cpt
 #if (KMP_ARCH_X86)
 MIN_MAX_CRITICAL_CPT(float16, max_a16_cpt, Quad_a16_t, <, 16r,
                      1) // __kmpc_atomic_float16_max_a16_cpt

 }
 
 void __kmpc_atomic_end(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("__kmpc_atomic_end: T#%d\n", gtid));
   __kmp_release_atomic_lock(&__kmp_atomic_lock, gtid);
 }
 
+// OpenMP 5.1 compare and swap
+
+/*!
+@param loc Source code location
+@param gtid Global thread id
+@param x Memory location to operate on
+@param e Expected value
+@param d Desired value
+@return Result of comparison
+
+Implements Compare And Swap atomic operation.
+
+Sample code:
+#pragma omp atomic compare update capture
+  { r = x == e; if(r) { x = d; } }
+*/
+bool __kmpc_atomic_bool_1_cas(ident_t *loc, int gtid, char *x, char e, char d) {
+  return KMP_COMPARE_AND_STORE_ACQ8(x, e, d);
+}
+bool __kmpc_atomic_bool_2_cas(ident_t *loc, int gtid, short *x, short e,
+                              short d) {
+  return KMP_COMPARE_AND_STORE_ACQ16(x, e, d);
+}
+bool __kmpc_atomic_bool_4_cas(ident_t *loc, int gtid, kmp_int32 *x, kmp_int32 e,
+                              kmp_int32 d) {
+  return KMP_COMPARE_AND_STORE_ACQ32(x, e, d);
+}
+bool __kmpc_atomic_bool_8_cas(ident_t *loc, int gtid, kmp_int64 *x, kmp_int64 e,
+                              kmp_int64 d) {
+  return KMP_COMPARE_AND_STORE_ACQ64(x, e, d);
+}
+
+/*!
+@param loc Source code location
+@param gtid Global thread id
+@param x Memory location to operate on
+@param e Expected value
+@param d Desired value
+@return Old value of x
+
+Implements Compare And Swap atomic operation.
+
+Sample code:
+#pragma omp atomic compare update capture
+  { v = x; if (x == e) { x = d; } }
+*/
+char __kmpc_atomic_val_1_cas(ident_t *loc, int gtid, char *x, char e, char d) {
+  return KMP_COMPARE_AND_STORE_RET8(x, e, d);
+}
+short __kmpc_atomic_val_2_cas(ident_t *loc, int gtid, short *x, short e,
+                              short d) {
+  return KMP_COMPARE_AND_STORE_RET16(x, e, d);
+}
+kmp_int32 __kmpc_atomic_val_4_cas(ident_t *loc, int gtid, kmp_int32 *x,
+                                  kmp_int32 e, kmp_int32 d) {
+  return KMP_COMPARE_AND_STORE_RET32(x, e, d);
+}
+kmp_int64 __kmpc_atomic_val_8_cas(ident_t *loc, int gtid, kmp_int64 *x,
+                                  kmp_int64 e, kmp_int64 d) {
+  return KMP_COMPARE_AND_STORE_RET64(x, e, d);
+}
+
+/*!
+@param loc Source code location
+@param gtid Global thread id
+@param x Memory location to operate on
+@param e Expected value
+@param d Desired value
+@param pv Captured value location
+@return Result of comparison
+
+Implements Compare And Swap + Capture atomic operation.
+
+v gets old valie of x if comparison failed, untouched otherwise.
+Sample code:
+#pragma omp atomic compare update capture
+  { r = x == e; if(r) { x = d; } else { v = x; } }
+*/
+bool __kmpc_atomic_bool_1_cas_cpt(ident_t *loc, int gtid, char *x, char e,
+                                  char d, char *pv) {
+  char old = KMP_COMPARE_AND_STORE_RET8(x, e, d);
+  if (old == e)
+    return true;
+  KMP_ASSERT(pv != NULL);
+  *pv = old;
+  return false;
+}
+bool __kmpc_atomic_bool_2_cas_cpt(ident_t *loc, int gtid, short *x, short e,
+                                  short d, short *pv) {
+  short old = KMP_COMPARE_AND_STORE_RET16(x, e, d);
+  if (old == e)
+    return true;
+  KMP_ASSERT(pv != NULL);
+  *pv = old;
+  return false;
+}
+bool __kmpc_atomic_bool_4_cas_cpt(ident_t *loc, int gtid, kmp_int32 *x,
+                                  kmp_int32 e, kmp_int32 d, kmp_int32 *pv) {
+  kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(x, e, d);
+  if (old == e)
+    return true;
+  KMP_ASSERT(pv != NULL);
+  *pv = old;
+  return false;
+}
+bool __kmpc_atomic_bool_8_cas_cpt(ident_t *loc, int gtid, kmp_int64 *x,
+                                  kmp_int64 e, kmp_int64 d, kmp_int64 *pv) {
+  kmp_int64 old = KMP_COMPARE_AND_STORE_RET64(x, e, d);
+  if (old == e)
+    return true;
+  KMP_ASSERT(pv != NULL);
+  *pv = old;
+  return false;
+}
+
+/*!
+@param loc Source code location
+@param gtid Global thread id
+@param x Memory location to operate on
+@param e Expected value
+@param d Desired value
+@param pv Captured value location
+@return Old value of x
+
+Implements Compare And Swap + Capture atomic operation.
+
+v gets new valie of x.
+Sample code:
+#pragma omp atomic compare update capture
+  { if (x == e) { x = d; }; v = x; }
+*/
+char __kmpc_atomic_val_1_cas_cpt(ident_t *loc, int gtid, char *x, char e,
+                                 char d, char *pv) {
+  char old = KMP_COMPARE_AND_STORE_RET8(x, e, d);
+  KMP_ASSERT(pv != NULL);
+  *pv = old == e ? d : old;
+  return old;
+}
+short __kmpc_atomic_val_2_cas_cpt(ident_t *loc, int gtid, short *x, short e,
+                                  short d, short *pv) {
+  short old = KMP_COMPARE_AND_STORE_RET16(x, e, d);
+  KMP_ASSERT(pv != NULL);
+  *pv = old == e ? d : old;
+  return old;
+}
+kmp_int32 __kmpc_atomic_val_4_cas_cpt(ident_t *loc, int gtid, kmp_int32 *x,
+                                      kmp_int32 e, kmp_int32 d, kmp_int32 *pv) {
+  kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(x, e, d);
+  KMP_ASSERT(pv != NULL);
+  *pv = old == e ? d : old;
+  return old;
+}
+kmp_int64 __kmpc_atomic_val_8_cas_cpt(ident_t *loc, int gtid, kmp_int64 *x,
+                                      kmp_int64 e, kmp_int64 d, kmp_int64 *pv) {
+  kmp_int64 old = KMP_COMPARE_AND_STORE_RET64(x, e, d);
+  KMP_ASSERT(pv != NULL);
+  *pv = old == e ? d : old;
+  return old;
+}
+
+// End OpenMP 5.1 compare + capture
+
 /*!
 @}
 */
 
 // end of file

openmp/runtime/test/atomic/kmp_atomic_cas.c

+// RUN: %libomp-compile-and-run
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <omp.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+typedef void* ident_t;
+extern bool
+__kmpc_atomic_bool_1_cas(ident_t *loc, int gtid, char *x, char e, char d);
+extern bool
+__kmpc_atomic_bool_2_cas(ident_t *loc, int gtid, short *x, short e, short d);
+extern bool
+__kmpc_atomic_bool_4_cas(ident_t *loc, int gtid, int *x, int e, int d);
+extern bool
+__kmpc_atomic_bool_8_cas(ident_t *loc, int gtid, long long *x, long long e,
+                         long long d);
+extern char
+__kmpc_atomic_val_1_cas(ident_t *loc, int gtid, char *x, char e, char d);
+extern short
+__kmpc_atomic_val_2_cas(ident_t *loc, int gtid, short *x, short e, short d);
+extern int
+__kmpc_atomic_val_4_cas(ident_t *loc, int gtid, int *x, int e, int d);
+extern long long
+__kmpc_atomic_val_8_cas(ident_t *loc, int gtid, long long *x, long long e,
+                        long long d);
+#ifdef  __cplusplus
+}
+#endif
+
+int main() {
+  int ret = 0;
+  bool r;
+  char c0 = 1;
+  char c1 = 2;
+  char c2 = 3;
+  char co = 2;
+  char cc = 0;
+  short s0 = 11;
+  short s1 = 12;
+  short s2 = 13;
+  short so = 12;
+  short sc = 0;
+  int i0 = 211;
+  int i1 = 212;
+  int i2 = 213;
+  int io = 212;
+  int ic = 0;
+  long long l0 = 3111;
+  long long l1 = 3112;
+  long long l2 = 3113;
+  long long lo = 3112;
+  long long lc = 0;
+
+// initialize OpenMP runtime library
+  omp_set_dynamic(0);
+
+//  #pragma omp atomic compare update capture
+//    { r = x == e; if(r) { x = d; } }
+// char, co == c1 initially, co == c2 finally
+  r = __kmpc_atomic_bool_1_cas(NULL, 0, &co, c0, c2); // no-op
+  if (co != c1) {
+    ret++; printf("Error bool_1_cas no-op: %d != %d\n", co, c1); }
+  if (r) { ret++; printf("Error bool_1_cas no-op ret: %d\n", r); }
+  r = __kmpc_atomic_bool_1_cas(NULL, 0, &co, c1, c2);
+  if (co != c2) {
+    ret++; printf("Error bool_1_cas: %d != %d\n", co, c2); }
+  if (!r) { ret++; printf("Error bool_1_cas ret: %d\n", r); }
+// short
+  r = __kmpc_atomic_bool_2_cas(NULL, 0, &so, s0, s2); // no-op
+  if (so != s1) {
+    ret++; printf("Error bool_2_cas no-op: %d != %d\n", so, s1); }
+  if (r) { ret++; printf("Error bool_2_cas no-op ret: %d\n", r); }
+  r = __kmpc_atomic_bool_2_cas(NULL, 0, &so, s1, s2);
+  if (so != s2) {
+    ret++; printf("Error bool_2_cas: %d != %d\n", so, s2); }
+  if (!r) { ret++; printf("Error bool_2_cas ret: %d\n", r); }
+// int
+  r = __kmpc_atomic_bool_4_cas(NULL, 0, &io, i0, i2); // no-op
+  if (io != i1) {
+    ret++; printf("Error bool_4_cas no-op: %d != %d\n", io, i1); }
+  if (r) { ret++; printf("Error bool_4_cas no-op ret: %d\n", r); }
+  r = __kmpc_atomic_bool_4_cas(NULL, 0, &io, i1, i2);
+  if (io != i2) {
+    ret++; printf("Error bool_4_cas: %d != %d\n", io, i2); }
+  if (!r) { ret++; printf("Error bool_4_cas ret: %d\n", r); }
+// long long
+  r = __kmpc_atomic_bool_8_cas(NULL, 0, &lo, l0, l2); // no-op
+  if (lo != l1) {
+    ret++; printf("Error bool_8_cas no-op: %lld != %lld\n", lo, l1); }
+  if (r) { ret++; printf("Error bool_8_cas no-op ret: %d\n", r); }
+  r = __kmpc_atomic_bool_8_cas(NULL, 0, &lo, l1, l2);
+  if (lo != l2) {
+    ret++; printf("Error bool_8_cas: %lld != %lld\n", lo, l2); }
+  if (!r) { ret++; printf("Error bool_8_cas ret: %d\n", r); }
+
+//  #pragma omp atomic compare update capture
+//    { v = x; if (x == e) { x = d; } }
+// char, co == c2 initially, co == c1 finally
+  cc = __kmpc_atomic_val_1_cas(NULL, 0, &co, c0, c1); // no-op
+  if (co != c2) {
+    ret++; printf("Error val_1_cas no-op: %d != %d\n", co, c2); }
+  if (cc != c2) {
+    ret++; printf("Error val_1_cas no-op ret: %d != %d\n", cc, c2); }
+  cc = __kmpc_atomic_val_1_cas(NULL, 0, &co, c2, c1);
+  if (co != c1) {
+    ret++; printf("Error val_1_cas: %d != %d\n", co, c1); }
+  if (cc != c2) { ret++; printf("Error val_1_cas ret: %d != %d\n", cc, c2); }
+// short
+  sc = __kmpc_atomic_val_2_cas(NULL, 0, &so, s0, s1); // no-op
+  if (so != s2) {
+    ret++; printf("Error val_2_cas no-op: %d != %d\n", so, s2); }
+  if (sc != s2) {
+    ret++; printf("Error val_2_cas no-op ret: %d != %d\n", sc, s2); }
+  sc = __kmpc_atomic_val_2_cas(NULL, 0, &so, s2, s1);
+  if (so != s1) {
+    ret++; printf("Error val_2_cas: %d != %d\n", so, s1); }
+  if (sc != s2) {
+    ret++; printf("Error val_2_cas ret: %d != %d\n", sc, s2); }
+// int
+  ic = __kmpc_atomic_val_4_cas(NULL, 0, &io, i0, i1); // no-op
+  if (io != i2) {
+    ret++; printf("Error val_4_cas no-op: %d != %d\n", io, i2); }
+  if (ic != i2) {
+    ret++; printf("Error val_4_cas no-op ret: %d != %d\n", ic, i2); }
+  ic = __kmpc_atomic_val_4_cas(NULL, 0, &io, i2, i1);
+  if (io != i1) {
+    ret++; printf("Error val_4_cas: %d != %d\n", io, i1); }
+  if (ic != i2) {
+    ret++; printf("Error val_4_cas ret: %d != %d\n", ic, i2); }
+// long long
+  lc = __kmpc_atomic_val_8_cas(NULL, 0, &lo, l0, l1); // no-op
+  if (lo != l2) {
+    ret++; printf("Error val_8_cas no-op: %lld != %lld\n", lo, l2); }
+  if (lc != l2) {
+    ret++; printf("Error val_8_cas no-op ret: %lld != %lld\n", lc, l2); }
+  lc = __kmpc_atomic_val_8_cas(NULL, 0, &lo, l2, l1);
+  if (lo != l1) {
+    ret++; printf("Error val_8_cas: %lld != %lld\n", lo, l1); }
+  if (lc != l2) {
+    ret++; printf("Error val_8_cas ret: %lld != %lld\n", lc, l2); }
+
+// check in parallel
+  i0 = 1;
+  i1 = 0;
+  for (io = 0; io < 5; ++io) {
+    #pragma omp parallel num_threads(2) private(i2, ic, r)
+    {
+      if (omp_get_thread_num() == 0) {
+        // th0 waits for th1 to increment i1, then th0 increments i0
+        #pragma omp atomic read
+          i2 = i1;
+        ic = __kmpc_atomic_val_4_cas(NULL, 0, &i0, i2, i2 + 1);
+        while(ic != i2) {
+          #pragma omp atomic read
+            i2 = i1;
+          ic = __kmpc_atomic_val_4_cas(NULL, 0, &i0, i2, i2 + 1);
+        }
+      } else {
+        // th1 increments i1 if it is equal to i0 - 1, letting th0 to proceed
+        r = 0;
+        while(!r) {
+          #pragma omp atomic read
+            i2 = i0;
+          r = __kmpc_atomic_bool_4_cas(NULL, 0, &i1, i2 - 1, i2);
+        }
+      }
+    }
+  }
+  if (i0 != 6 || i1 != 5) {
+    ret++;
+    printf("Error in parallel, %d != %d or %d != %d\n", i0, 6, i1, 5);
+  }
+
+  if (ret == 0)
+    printf("passed\n");
+  return ret;
+}

openmp/runtime/test/atomic/kmp_atomic_cas_cpt.c

+// RUN: %libomp-compile-and-run
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <omp.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+typedef void* ident_t;
+extern bool
+__kmpc_atomic_bool_1_cas_cpt(ident_t *loc, int gtid, char *x, char e, char d,
+                             char *pv);
+extern bool
+__kmpc_atomic_bool_2_cas_cpt(ident_t *loc, int gtid, short *x, short e, short d,
+                             short *pv);
+extern bool
+__kmpc_atomic_bool_4_cas_cpt(ident_t *loc, int gtid, int *x, int e, int d,
+                             int *pv);
+extern bool
+__kmpc_atomic_bool_8_cas_cpt(ident_t *loc, int gtid, long long *x, long long e,
+                             long long d, long long *pv);
+extern char
+__kmpc_atomic_val_1_cas_cpt(ident_t *loc, int gtid, char *x, char e, char d,
+                            char *pv);
+extern short
+__kmpc_atomic_val_2_cas_cpt(ident_t *loc, int gtid, short *x, short e, short d,
+                            short *pv);
+extern int
+__kmpc_atomic_val_4_cas_cpt(ident_t *loc, int gtid, int *x, int e, int d,
+                            int *pv);
+extern long long
+__kmpc_atomic_val_8_cas_cpt(ident_t *loc, int gtid, long long *x, long long e,
+                            long long d, long long *pv);
+#ifdef  __cplusplus
+}
+#endif
+
+int main() {
+  int ret = 0;
+  bool r;
+  char c0 = 1;
+  char c1 = 2;
+  char c2 = 3;
+  char co = 2;
+  char cc = 0;
+  char cv = 0;
+  short s0 = 11;
+  short s1 = 12;
+  short s2 = 13;
+  short so = 12;
+  short sc = 0;
+  short sv = 0;
+  int i0 = 211;
+  int i1 = 212;
+  int i2 = 213;
+  int io = 212;
+  int ic = 0;
+  int iv = 0;
+  long long l0 = 3111;
+  long long l1 = 3112;
+  long long l2 = 3113;
+  long long lo = 3112;
+  long long lc = 0;
+  long long lv = 0;
+
+// initialize OpenMP runtime library
+  omp_set_dynamic(0);
+
+//  #pragma omp atomic compare update capture
+//    { r = x == e; if(r) { x = d; } else { v = x; } }
+// char, co == c1 initially, co == c2 finally
+  r = __kmpc_atomic_bool_1_cas_cpt(NULL, 0, &co, c0, c2, &cv); // no-op
+  if (co != c1) {
+    ret++; printf("Error bool_1_cas_cpt no-op: %d != %d\n", co, c1); }
+  if (cv != co) {
+    ret++; printf("Error bool_1_cas_cpt no-op cpt: %d != %d\n", cv, co); }
+  if (r) { ret++; printf("Error bool_1_cas_cpt no-op ret: %d\n", r); }
+  cv = 0;
+  r = __kmpc_atomic_bool_1_cas_cpt(NULL, 0, &co, c1, c2, &cv);
+  if (co != c2) { ret++; printf("Error bool_1_cas_cpt: %d != %d\n", co, c2); }
+  if (cv != 0) { ret++; printf("Error bool_1_cas_cpt cpt: %d != %d\n", cv, 0); }
+  if (!r) { ret++; printf("Error bool_1_cas_cpt ret: %d\n", r); }
+// short
+  r = __kmpc_atomic_bool_2_cas_cpt(NULL, 0, &so, s0, s2, &sv); // no-op
+  if (so != s1) {
+    ret++; printf("Error bool_2_cas_cpt no-op: %d != %d\n", so, s1); }
+  if (sv != so) {
+    ret++; printf("Error bool_2_cas_cpt no-op cpt: %d != %d\n", sv, so); }
+  if (r) { ret++; printf("Error bool_2_cas_cpt no-op ret: %d\n", r); }
+  sv = 0;
+  r = __kmpc_atomic_bool_2_cas_cpt(NULL, 0, &so, s1, s2, &sv);
+  if (so != s2) { ret++; printf("Error bool_2_cas_cpt: %d != %d\n", so, s2); }
+  if (sv != 0) { ret++; printf("Error bool_2_cas_cpt cpt: %d != %d\n", sv, 0); }
+  if (!r) { ret++; printf("Error bool_2_cas_cpt ret: %d\n", r); }
+// int
+  r = __kmpc_atomic_bool_4_cas_cpt(NULL, 0, &io, i0, i2, &iv); // no-op
+  if (io != i1) {
+    ret++; printf("Error bool_4_cas_cpt no-op: %d != %d\n", io, i1); }
+  if (iv != io) {
+    ret++; printf("Error bool_4_cas_cpt no-op cpt: %d != %d\n", iv, io); }
+  if (r) { ret++; printf("Error bool_4_cas_cpt no-op ret: %d\n", r); }
+  iv = 0;
+  r = __kmpc_atomic_bool_4_cas_cpt(NULL, 0, &io, i1, i2, &iv);
+  if (io != i2) { ret++; printf("Error bool_4_cas_cpt: %d != %d\n", io, i2); }
+  if (iv != 0) { ret++; printf("Error bool_4_cas_cpt cpt: %d != %d\n", iv, 0); }
+  if (!r) { ret++; printf("Error bool_4_cas_cpt ret: %d\n", r); }
+// long long
+  r = __kmpc_atomic_bool_8_cas_cpt(NULL, 0, &lo, l0, l2, &lv); // no-op
+  if (lo != l1) {
+    ret++; printf("Error bool_8_cas_cpt no-op: %lld != %lld\n", lo, l1); }
+  if (lv != lo) {
+    ret++; printf("Error bool_8_cas_cpt no-op cpt: %lld != %lld\n", lv, lo); }
+  if (r) { ret++; printf("Error bool_8_cas_cpt no-op ret: %d\n", r); }
+  lv = 0;
+  r = __kmpc_atomic_bool_8_cas_cpt(NULL, 0, &lo, l1, l2, &lv);
+  if (lo != l2) {
+    ret++; printf("Error bool_8_cas_cpt: %lld != %lld\n", lo, l2); }
+  if (lv != 0) { // should not be assigned
+    ret++; printf("Error bool_8_cas_cpt cpt: %lld != %d\n", lv, 0); }
+  if (!r) { ret++; printf("Error bool_8_cas_cpt ret: %d\n", r); }
+
+//  #pragma omp atomic compare update capture
+//    { if (x == e) { x = d; }; v = x; }
+// char, co == c2 initially, co == c1 finally
+  cc = __kmpc_atomic_val_1_cas_cpt(NULL, 0, &co, c0, c1, &cv); // no-op
+  if (co != c2) {
+    ret++; printf("Error val_1_cas_cpt no-op: %d != %d\n", co, c2); }
+  if (cv != c2) {
+    ret++; printf("Error val_1_cas_cpt no-op cpt: %d != %d\n", cv, c2); }
+  if (cc != c2) {
+    ret++; printf("Error val_1_cas_cpt no-op ret: %d != %d\n", cc, c2); }
+  cc = __kmpc_atomic_val_1_cas_cpt(NULL, 0, &co, c2, c1, &cv);
+  if (co != c1) { ret++; printf("Error val_1_cas_cpt: %d != %d\n", co, c1); }
+  if (cv != c1) { ret++; printf("Error val_1_cas_cpt cpt: %d != %d\n", cv, c1); }
+  if (cc != c2) { ret++; printf("Error val_1_cas_cpt ret: %d != %d\n", cc, c2); }
+// short
+  sc = __kmpc_atomic_val_2_cas_cpt(NULL, 0, &so, s0, s1, &sv); // no-op
+  if (so != s2) {
+    ret++; printf("Error val_2_cas_cpt no-op: %d != %d\n", so, s2); }
+  if (sv != s2) {
+    ret++; printf("Error val_2_cas_cpt no-op cpt: %d != %d\n", sv, s2); }
+  if (sc != s2) {
+    ret++; printf("Error val_2_cas_cpt no-op ret: %d != %d\n", sc, s2); }
+  sc = __kmpc_atomic_val_2_cas_cpt(NULL, 0, &so, s2, s1, &sv);
+  if (so != s1) { ret++; printf("Error val_2_cas_cpt: %d != %d\n", so, s1); }
+  if (sv != s1) { ret++; printf("Error val_2_cas_cpt cpt: %d != %d\n", sv, s1); }
+  if (sc != s2) { ret++; printf("Error val_2_cas_cpt ret: %d != %d\n", sc, s2); }
+// int
+  ic = __kmpc_atomic_val_4_cas_cpt(NULL, 0, &io, i0, i1, &iv); // no-op
+  if (io != i2) {
+    ret++; printf("Error val_4_cas_cpt no-op: %d != %d\n", io, i2); }
+  if (iv != i2) {
+    ret++; printf("Error val_4_cas_cpt no-op cpt: %d != %d\n", iv, i2); }
+  if (ic != i2) {
+    ret++; printf("Error val_4_cas_cpt no-op ret: %d != %d\n", ic, i2); }
+  ic = __kmpc_atomic_val_4_cas_cpt(NULL, 0, &io, i2, i1, &iv);
+  if (io != i1) { ret++; printf("Error val_4_cas_cpt: %d != %d\n", io, i1); }
+  if (iv != i1) { ret++; printf("Error val_4_cas_cpt cpt: %d != %d\n", io, i1); }
+  if (ic != i2) { ret++; printf("Error val_4_cas_cpt ret: %d != %d\n", ic, i2); }
+// long long
+  lc = __kmpc_atomic_val_8_cas_cpt(NULL, 0, &lo, l0, l1, &lv); // no-op
+  if (lo != l2) {
+    ret++; printf("Error val_8_cas_cpt no-op: %lld != %lld\n", lo, l2); }
+  if (lv != l2) {
+    ret++; printf("Error val_8_cas_cpt no-op cpt: %lld != %lld\n", lv, l2); }
+  if (lc != l2) {
+    ret++; printf("Error val_8_cas_cpt no-op ret: %lld != %lld\n", lc, l2); }
+  lc = __kmpc_atomic_val_8_cas_cpt(NULL, 0, &lo, l2, l1, &lv);
+  if (lo != l1) { ret++; printf("Error val_8_cas_cpt: %lld != %lld\n", lo, l1); }
+  if (lv != l1) {
+    ret++; printf("Error val_8_cas_cpt cpt: %lld != %lld\n", lv, l1); }
+  if (lc != l2) {
+    ret++; printf("Error val_8_cas_cpt ret: %lld != %lld\n", lc, l2); }
+
+// check in parallel
+  i0 = 1;
+  i1 = 0;
+  for (io = 0; io < 5; ++io) {
+    #pragma omp parallel num_threads(2) private(i2, ic, r, iv)
+    {
+      if (omp_get_thread_num() == 0) {
+        // th0 waits for th1 to increment i1, then th0 increments i0
+        #pragma omp atomic read
+          i2 = i1;
+        ic = __kmpc_atomic_val_4_cas_cpt(NULL, 0, &i0, i2, i2 + 1, &iv);
+        while(ic != i2) {
+          if (iv != ic) {
+            ret++;
+            printf("Error 1 in parallel cpt, %d != %d\n", iv, ic);
+          }
+          #pragma omp atomic read
+            i2 = i1;
+          ic = __kmpc_atomic_val_4_cas_cpt(NULL, 0, &i0, i2, i2 + 1, &iv);
+        }
+        if (iv != i2 + 1) {
+          ret++;
+          printf("Error 2 in parallel cpt, %d != %d\n", iv, i2 + 1);
+        }
+      } else {
+        // th1 increments i1 if it is equal to i0 - 1, letting th0 to proceed
+        r = 0;
+        while(!r) {
+          #pragma omp atomic read
+            i2 = i0;
+          r = __kmpc_atomic_bool_4_cas_cpt(NULL, 0, &i1, i2 - 1, i2, &iv);
+        }
+      }
+    }
+  }
+  if (i0 != 6 || i1 != 5) {
+    ret++;
+    printf("Error in parallel, %d != %d or %d != %d\n", i0, 6, i1, 5);
+  }
+
+  if (ret == 0)
+    printf("passed\n");
+  return ret;
+}

openmp/runtime/test/atomic/kmp_atomic_float10_max_min.c

+// RUN: %libomp-compile -mlong-double-80 && %libomp-run
+// UNSUPPORTED: gcc
+
+#include <stdio.h>
+#include <omp.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+typedef void* ident_t;
+extern void __kmpc_atomic_float10_max(ident_t *id_ref, int gtid,
+                                      long double *lhs, long double rhs);
+extern void __kmpc_atomic_float10_min(ident_t *id_ref, int gtid,
+                                      long double *lhs, long double rhs);
+extern long double __kmpc_atomic_float10_max_cpt(ident_t *id_ref, int gtid,
+                                                 long double *lhs,
+                                                 long double rhs, int flag);
+extern long double __kmpc_atomic_float10_min_cpt(ident_t *id_ref, int gtid,
+                                                 long double *lhs,
+                                                 long double rhs, int flag);
+#ifdef  __cplusplus
+}
+#endif
+
+int main() {
+  int ret = 0;
+  long double s = 012.3456; // small
+  long double e = 123.4567; // middle
+  long double d = 234.5678; // big
+  long double x = 123.4567; // object
+  long double v = 0.; // captured value
+
+// initialize OpenMP runtime library
+  omp_set_num_threads(4);
+
+// max
+//  #pragma omp atomic compare update
+//    if (x < d) x = d;
+  __kmpc_atomic_float10_max(NULL, 0, &x, d);
+  if (x != d) {
+    ret++;
+    printf("Error max: %Lf != %Lf\n", x, d);
+  }
+  __kmpc_atomic_float10_max(NULL, 0, &x, s); // no-op
+  if (x != d) {
+    ret++;
+    printf("Error max: %Lf != %Lf\n", x, d);
+  }
+
+// min
+//  #pragma omp atomic compare update
+//    if (x > s) x = s;
+  __kmpc_atomic_float10_min(NULL, 0, &x, s);
+  if (x != s) {
+    ret++;
+    printf("Error min: %Lf != %Lf\n", x, s);
+  }
+  __kmpc_atomic_float10_min(NULL, 0, &x, e); // no-op
+  if (x != s) {
+    ret++;
+    printf("Error min: %Lf != %Lf\n", x, s);
+  }
+
+// max_cpt old
+//  #pragma omp atomic compare update capture
+//    { v = x; if (x < d) x = d; }
+  v = __kmpc_atomic_float10_max_cpt(NULL, 0, &x, d, 0);
+  if (x != d) {
+    ret++;
+    printf("Error max_cpt obj: %Lf != %Lf\n", x, d);
+  }
+  if (v != s) {
+    ret++;
+    printf("Error max_cpt cpt: %Lf != %Lf\n", v, s);
+  }
+  v = __kmpc_atomic_float10_max_cpt(NULL, 0, &x, e, 0); // no-op
+  if (x != d) {
+    ret++;
+    printf("Error max_cpt obj: %Lf != %Lf\n", x, d);
+  }
+  if (v != d) {
+    ret++;
+    printf("Error max_cpt cpt: %Lf != %Lf\n", v, d);
+  }
+
+// min_cpt old
+//  #pragma omp atomic compare update capture
+//    { v = x; if (x > d) x = d; }
+  v = __kmpc_atomic_float10_min_cpt(NULL, 0, &x, s, 0);
+  if (x != s) {
+    ret++;
+    printf("Error min_cpt obj: %Lf != %Lf\n", x, s);
+  }
+  if (v != d) {
+    ret++;
+    printf("Error min_cpt cpt: %Lf != %Lf\n", v, d);
+  }
+  v = __kmpc_atomic_float10_min_cpt(NULL, 0, &x, e, 0); // no-op
+  if (x != s) {
+    ret++;
+    printf("Error max_cpt obj: %Lf != %Lf\n", x, s);
+  }
+  if (v != s) {
+    ret++;
+    printf("Error max_cpt cpt: %Lf != %Lf\n", v, s);
+  }
+
+// max_cpt new
+//  #pragma omp atomic compare update capture
+//    { if (x < d) x = d; v = x; }
+  v = __kmpc_atomic_float10_max_cpt(NULL, 0, &x, d, 1);
+  if (x != d) {
+    ret++;
+    printf("Error max_cpt obj: %Lf != %Lf\n", x, d);
+  }
+  if (v != d) {
+    ret++;
+    printf("Error max_cpt cpt: %Lf != %Lf\n", v, d);
+  }
+  v = __kmpc_atomic_float10_max_cpt(NULL, 0, &x, e, 1); // no-op
+  if (x != d) {
+    ret++;
+    printf("Error max_cpt obj: %Lf != %Lf\n", x, d);
+  }
+  if (v != d) {
+    ret++;
+    printf("Error max_cpt cpt: %Lf != %Lf\n", v, d);
+  }
+
+// min_cpt new
+//  #pragma omp atomic compare update capture
+//    { if (x > d) x = d; v = x; }
+  v = __kmpc_atomic_float10_min_cpt(NULL, 0, &x, s, 1);
+  if (x != s) {
+    ret++;
+    printf("Error min_cpt obj: %Lf != %Lf\n", x, s);
+  }
+  if (v != s) {
+    ret++;
+    printf("Error min_cpt cpt: %Lf != %Lf\n", v, s);
+  }
+  v = __kmpc_atomic_float10_min_cpt(NULL, 0, &x, e, 1); // no-op
+  if (x != s) {
+    ret++;
+    printf("Error max_cpt obj: %Lf != %Lf\n", x, s);
+  }
+  if (v != s) {
+    ret++;
+    printf("Error max_cpt cpt: %Lf != %Lf\n", v, s);
+  }
+
+  if (ret == 0)
+    printf("passed\n");
+  return ret;
+}