[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

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

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.

test/tsan/barrier.cc

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 // CHECK-NOT: ThreadSanitizer: data race
 // CHECK: DONE
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <unistd.h>
+#include "test.h"
 
 const int kSize = 4;
 volatile int kIter = 10;  // prevent unwinding
 int data[2][kSize];
 pthread_barrier_t barrier;
 
 void *thr(void *p) {
   int idx = (int)(long)p;

test/tsan/bench.h

 #include <pthread.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <time.h>
 
+#include "test.h"
+
 int bench_nthread;
 int bench_niter;
 int grow_clock_var;
 pthread_barrier_t glow_clock_barrier;
 
 void bench();  // defined by user
 void start_thread_group(int nth, void(*f)(int tid));
 void grow_clock_worker(int tid);
int main(int argc, char **argv) {
   int clock_size = 10;
   if (argc > 1)
     clock_size = 1000;
   pthread_barrier_init(&glow_clock_barrier, 0, clock_size);
   start_thread_group(clock_size, grow_clock_worker);
   pthread_barrier_destroy(&glow_clock_barrier);
   __atomic_load_n(&grow_clock_var, __ATOMIC_ACQUIRE);
 
-  timespec tp0;
-  clock_gettime(CLOCK_MONOTONIC, &tp0);
+  BENCH_STOPWATCH_START();
   bench();
-  timespec tp1;
-  clock_gettime(CLOCK_MONOTONIC, &tp1);
-  unsigned long long t =
-      (tp1.tv_sec * 1000000000ULL + tp1.tv_nsec) -
-      (tp0.tv_sec * 1000000000ULL + tp0.tv_nsec);
+  BENCH_STOPWATCH_STOP();
   fprintf(stderr, "%llu ns/iter\n", t / bench_niter);
   fprintf(stderr, "DONE\n");
 }
 
 void start_thread_group(int nth, void(*f)(int tid)) {
   pthread_t *th = (pthread_t*)malloc(nth * sizeof(pthread_t));
   for (int i = 0; i < nth; i++)
     pthread_create(&th[i], 0, (void*(*)(void*))f, (void*)(long)i);

test/tsan/race_on_barrier2.c

 // RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-#include <pthread.h>
-#include <stdio.h>
-#include <stddef.h>
-#include <unistd.h>
+#include "test.h"
 
 pthread_barrier_t B;
 int Global;
 
 void *Thread1(void *x) {
   if (pthread_barrier_wait(&B) == PTHREAD_BARRIER_SERIAL_THREAD)
     pthread_barrier_destroy(&B);
   return NULL;

test/tsan/test.h

+#include <assert.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <dlfcn.h>
 #include <stddef.h>
 #include <sched.h>
 
+#ifdef __APPLE__
+#include <mach/mach_time.h>
+#endif
+
 // TSan-invisible barrier.
 // Tests use it to establish necessary execution order in a way that does not
 // interfere with tsan (does not establish synchronization between threads).
 // 8 lsb is thread count, the remaining are count of entered threads.
 typedef unsigned long long invisible_barrier_t;
 
 void barrier_init(invisible_barrier_t *barrier, unsigned count) {
   if (count >= (1 << 8))
#elif defined(__aarch64__)
   else {
     fprintf(stderr, "unsupported vma: %ul\n", vma);
     exit(1);
   }
 
   fprintf(stderr, format, (unsigned long) address);
 #endif
 }
+
+#ifdef __APPLE__
+
+// Darwin doesn't have pthread_barrier_* APIs, let's re-implement them with
+// mutexes and condition variables.
+typedef int pthread_barrierattr_t;
+typedef struct {
+  pthread_mutex_t mutex;
+  pthread_cond_t cond;
+  int current_count;
+  int max_count;
+} pthread_barrier_t;
+#define PTHREAD_BARRIER_SERIAL_THREAD 1
+
+int pthread_barrier_init(pthread_barrier_t *barrier,
+                         const pthread_barrierattr_t *attr, unsigned count) {
+  assert(count > 0);
+  assert(pthread_mutex_init(&barrier->mutex, 0) == 0);
+  assert(pthread_cond_init(&barrier->cond, 0) == 0);
+  barrier->max_count = count;
+  barrier->current_count = 0;
+  return 0;
+}
+
+int pthread_barrier_wait(pthread_barrier_t *barrier) {
+  pthread_mutex_lock(&barrier->mutex);
+  barrier->current_count += 1;
+  if (barrier->current_count >= barrier->max_count) {
+    barrier->current_count = 0;
+    pthread_cond_broadcast(&barrier->cond);
+    pthread_mutex_unlock(&barrier->mutex);
+    return PTHREAD_BARRIER_SERIAL_THREAD;
+  } else {
+    pthread_cond_wait(&barrier->cond, &barrier->mutex);
+    pthread_mutex_unlock(&barrier->mutex);
+    return 0;
+  }
+}
+
+int pthread_barrier_destroy(pthread_barrier_t *barrier) {
+  pthread_cond_destroy(&barrier->cond);
+  pthread_mutex_destroy(&barrier->mutex);
+  return 0;
+}
+
+unsigned long long darwin_uptime() {
+  static mach_timebase_info_data_t timebase_info;
+  if (timebase_info.denom == 0) mach_timebase_info(&timebase_info);
+  return (mach_absolute_time() * timebase_info.numer) / timebase_info.denom;
+}
+
+#define BENCH_STOPWATCH_START() \
+  unsigned long long tp0 = darwin_uptime()
+#define BENCH_STOPWATCH_STOP() \
+  unsigned long long tp1 = darwin_uptime(); \
+  unsigned long long t = tp1 - tp0
+
+#else  // __APPLE__
+
+#define BENCH_STOPWATCH_START() \
+  timespec tp0; \
+  clock_gettime(CLOCK_MONOTONIC, &tp0)
+#define BENCH_STOPWATCH_STOP() \
+  timespec tp1; \
+  clock_gettime(CLOCK_MONOTONIC, &tp1); \
+  unsigned long long t = \
+      (tp1.tv_sec * 1000000000ULL + tp1.tv_nsec) - \
+      (tp0.tv_sec * 1000000000ULL + tp0.tv_nsec)
+
+#endif  // __APPLE__