| // RUN: %libomp-compile-and-run |
| |
| #include <stdio.h> |
| #include <stdbool.h> |
| #include <omp.h> |
| |
| // Used to detect architecture |
| #include "../../src/kmp_platform.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; |
| #if KMP_ARCH_X86 || KMP_ARCH_X86_64 |
| 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"); |
| #else |
| printf("Unsupported architecture, skipping test...\n"); |
| #endif // KMP_ARCH_X86 || KMP_ARCH_X86_64 |
| return ret; |
| } |