[tsan] Mark tests that need pthread barriers with "UNSUPPORTED: darwin"

[kubamracek]

Summary

Several testcases need pthread barriers (e.g. all bench_*.cc which use test/tsan/bench.h) which are not available on OS X. Let's mark them with "UNSUPPORTED: darwin".

[dvyukov]

test/tsan/barrier.cc

5 ↗

(On Diff #40112)

What's the point of testing our own implementation of barrier that nobody else uses (and so it's correctness is actually irrelevant)? We are not trying to re-implement on linux all darwin synchronization primitives like GCD, right. Can we just use the UNSUPPORTED directive, of if that does not work ifdef it out?

test/tsan/test.h

119 ↗

(On Diff #40112)

I don't see a need for macros here. Please wrap it into functions with iface along the lines of:

typedef ... benchtime_t;
void bench_start(benchtime_t*);
unsigned long long bench_end(benchtime_t);

[kubamracek]

Updating patch to instead use "UNSUPPORTED: darwin" in tests that require pthread barriers.

[kubamracek]

Adding "UNSUPPORTED: darwin" to one more test (test/tsan/barrier.cc).

[dvyukov]

LGTM

My comment was related only to barrier tests.
As for benchmarks, they are still useful on mac. Eventually we need to change bench.h to not rely on pthread_barrier and grow clocks using some other synchronization primitive that is supported on all platforms.

[kubamracek]

OK, I'll try to look at supporting the benchmarks on OS X later.

compiler-rt/trunk/test/tsan/barrier.cc

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 // CHECK-NOT: ThreadSanitizer: data race
 // CHECK: DONE
 
+// pthread barriers are not available on OS X
+// UNSUPPORTED: darwin
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <unistd.h>
 
 const int kSize = 4;
 volatile int kIter = 10;  // prevent unwinding
 int data[2][kSize];

compiler-rt/trunk/test/tsan/bench_acquire_only.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "bench.h"
 
 int x;
 
 void thread(int tid) {
   for (int i = 0; i < bench_niter; i++)
     __atomic_load_n(&x, __ATOMIC_ACQUIRE);
 }
 
 void bench() {
   __atomic_store_n(&x, 0, __ATOMIC_RELEASE);
   start_thread_group(bench_nthread, thread);
 }
 
 // CHECK: DONE
 

compiler-rt/trunk/test/tsan/bench_acquire_release.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "bench.h"
 
 int x;
 
 void thread(int tid) {
   for (int i = 0; i < bench_niter; i++)
     __atomic_fetch_add(&x, 1, __ATOMIC_ACQ_REL);
 }
 
 void bench() {
   start_thread_group(bench_nthread, thread);
 }
 
 // CHECK: DONE
 

compiler-rt/trunk/test/tsan/bench_local_mutex.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "bench.h"
 
 pthread_mutex_t *mtx;
 const int kStride = 16;
 
 void thread(int tid) {
   for (int i = 0; i < bench_niter; i++) {
     pthread_mutex_lock(&mtx[tid * kStride]);

compiler-rt/trunk/test/tsan/bench_mutex.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "bench.h"
 
 pthread_mutex_t mtx;
 pthread_cond_t cv;
 int x;
 
 void thread(int tid) {
   for (int i = 0; i < bench_niter; i++) {

compiler-rt/trunk/test/tsan/bench_release_only.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "bench.h"
 
 int *x;
 const int kStride = 32;
 
 void thread(int tid) {
   __atomic_load_n(&x[tid * kStride], __ATOMIC_ACQUIRE);
   for (int i = 0; i < bench_niter; i++)

compiler-rt/trunk/test/tsan/bench_rwmutex.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "bench.h"
 
 pthread_rwlock_t mtx;
 
 void thread(int tid) {
   for (int i = 0; i < bench_niter; i++) {
     pthread_rwlock_rdlock(&mtx);
     pthread_rwlock_unlock(&mtx);

compiler-rt/trunk/test/tsan/bench_single_writer.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "bench.h"
 
 int x;
 
 void thread(int tid) {
   if (tid == 0) {
     for (int i = 0; i < bench_niter; i++)
       __atomic_store_n(&x, 0, __ATOMIC_RELEASE);

compiler-rt/trunk/test/tsan/bench_ten_mutexes.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "bench.h"
 
 const int kMutex = 10;
 pthread_mutex_t mtx[kMutex];
 
 void thread(int tid) {
   for (int i = 0; i < bench_niter; i++) {
     int idx = (i % kMutex);

compiler-rt/trunk/test/tsan/race_on_barrier.c

 // RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+
+// pthread barriers are not available on OS X
+// UNSUPPORTED: darwin
+
 #include "test.h"
 
 pthread_barrier_t B;
 int Global;
 
 void *Thread1(void *x) {
   pthread_barrier_init(&B, 0, 2);
   barrier_wait(&barrier);

compiler-rt/trunk/test/tsan/race_on_barrier2.c

 // RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+
+// pthread barriers are not available on OS X
+// UNSUPPORTED: darwin
+
 #include <pthread.h>
 #include <stdio.h>
 #include <stddef.h>
 #include <unistd.h>
 
 pthread_barrier_t B;
 int Global;