[tsan] Make tests that use CLOCK_MONOTONIC portable

[kubamracek]

Summary

Several tests rely on CLOCK_MONOTONIC, which doesn't exist on OS X. This patch fixes these tests by either disabling them (in case of cond_version.c which doesn't make sense on OS X), or by porting the test to also work on OS X.

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

 // RUN: %clang_tsan -O1 %s -o %t -lrt && %run %t 2>&1 | FileCheck %s
 // Test that pthread_cond is properly intercepted,
 // previously there were issues with versioned symbols.
 // CHECK: OK
 
+// OS X doesn't have pthread_condattr_setclock.
+// UNSUPPORTED: darwin
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <time.h>
 #include <errno.h>
 
 int main() {
   typedef unsigned long long u64;

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

 // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <time.h>
 #include <errno.h>
 #include <vector>
 #include <algorithm>
+#include <sys/time.h>
 
 const int kThreads = 4;
 const int kMutexes = 16 << 10;
 const int kIters = 400 << 10;
 const int kMaxPerThread = 10;
 
 const int kStateInited = 0;
 const int kStateNotInited = -1;
if ((err = pthread_rwlock_unlock(&m->m))) {
       fprintf(stderr, "pthread_rwlock_unlock failed with %d\n", err);
       exit(1);
     }
   }
   return 0;
 }
 
 int main() {
-  timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  unsigned s = (unsigned)ts.tv_nsec;
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  unsigned s = tv.tv_sec + tv.tv_usec;
   fprintf(stderr, "seed %d\n", s);
   srand(s);
   for (int i = 0; i < kMutexes; i++)
     mtx[i].state = kStateNotInited;
   pthread_t t[kThreads];
   for (int i = 0; i < kThreads; i++)
     pthread_create(&t[i], 0, Thread, (void*)(unsigned long)rand());
   for (int i = 0; i < kThreads; i++)
     pthread_join(t[i], 0);
   fprintf(stderr, "DONE\n");
   return 0;
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer
 // CHECK: DONE
 

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

 // RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=flush_memory_ms=1:memory_limit_mb=1 %run %t 2>&1 | FileCheck %s
 #include "test.h"
 #include <sys/types.h>
 #include <unistd.h>
 #include <time.h>
 
 // Test that setuid call works in presence of stoptheworld.
 
 int main() {
-  struct timespec tp0, tp1;
-  clock_gettime(CLOCK_MONOTONIC, &tp0);
-  clock_gettime(CLOCK_MONOTONIC, &tp1);
-  while (tp1.tv_sec - tp0.tv_sec < 3) {
-    clock_gettime(CLOCK_MONOTONIC, &tp1);
+  unsigned long long tp0, tp1;
+  tp0 = monotonic_clock_ns();
+  tp1 = monotonic_clock_ns();
+  while (tp1 - tp0 < 3 * 1000000000ull) {
+    tp1 = monotonic_clock_ns();
     setuid(0);
   }
   fprintf(stderr, "DONE\n");
   return 0;
 }
 
 // CHECK: DONE

compiler-rt/trunk/test/tsan/test.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__
+unsigned long long monotonic_clock_ns() {
+  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;
+}
+#else
+unsigned long long monotonic_clock_ns() {
+  struct timespec t;
+  clock_gettime(CLOCK_MONOTONIC, &t);
+  return (unsigned long long)t.tv_sec * 1000000000ull + t.tv_nsec;
+}
+#endif