tsan: add more micro benchmarks

[dvyukov]

Summary

1. Add a set of micro benchmarks for memory accesses, mem* functions and unaligned accesses.
2. Add support for multiple benchmarks in a single binary (or it would require 12 new benchmark binaries).
3. Remove the "clock growth" machinery, it affects the current tsan runtime by increasing size of all vector clocks, but this won't be relevant for the new tsan runtime.

compiler-rt/test/tsan/bench.h

-#include <pthread.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <unistd.h>
-#include <stdio.h>
+#include "test.h"
 #include <time.h>
 
 int bench_nthread;
 int bench_niter;
-int grow_clock_var;
-pthread_barrier_t glow_clock_barrier;
+int bench_mode;
 
 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) {
   bench_nthread = 2;
   if (argc > 1)
     bench_nthread = atoi(argv[1]);
   bench_niter = 100;
   if (argc > 2)
     bench_niter = atoi(argv[2]);
-
-  // Grow thread's clock.
-  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);
+  if (argc > 3)
+    bench_mode = atoi(argv[3]);
 
   timespec tp0;
   clock_gettime(CLOCK_MONOTONIC, &tp0);
   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);
   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);
   for (int i = 0; i < nth; i++)
     pthread_join(th[i], 0);
 }
-
-void grow_clock_worker(int tid) {
-  int res = pthread_barrier_wait(&glow_clock_barrier);
-  if (res == PTHREAD_BARRIER_SERIAL_THREAD)
-    __atomic_store_n(&grow_clock_var, 0, __ATOMIC_RELEASE);
-}
-

compiler-rt/test/tsan/bench_memory_access.cpp

+// 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"
+#include <memory.h>
+
+void thread(int tid) {
+  volatile long x = 0;
+  switch (bench_mode) {
+  case 0:
+    for (int i = 0; i < bench_niter; i++)
+      *(volatile char *)&x = 1;
+    break;
+  case 1:
+    for (int i = 0; i < bench_niter; i++)
+      *(volatile short *)&x = 1;
+    break;
+  case 2:
+    for (int i = 0; i < bench_niter; i++)
+      *(volatile int *)&x = 1;
+    break;
+  case 3:
+    for (int i = 0; i < bench_niter; i++)
+      *(volatile long *)&x = 1;
+    break;
+  case 4:
+    for (int i = 0; i < bench_niter; i++)
+      *(volatile char *)&x;
+    break;
+  case 5:
+    for (int i = 0; i < bench_niter; i++)
+      *(volatile short *)&x;
+    break;
+  case 6:
+    for (int i = 0; i < bench_niter; i++)
+      *(volatile int *)&x;
+    break;
+  case 7:
+    for (int i = 0; i < bench_niter; i++)
+      *(volatile long *)&x;
+  case 8:
+    for (int i = 0; i < bench_niter / 10; i++) {
+      ((volatile long *)&x)[0];
+      ((volatile int *)&x)[0];
+      ((volatile short *)&x)[2];
+      ((volatile char *)&x)[6];
+      ((volatile char *)&x)[7];
+      ((volatile long *)&x)[0] = 1;
+      ((volatile int *)&x)[0] = 1;
+      ((volatile short *)&x)[2] = 1;
+      ((volatile char *)&x)[6] = 1;
+      ((volatile char *)&x)[7] = 1;
+    }
+    break;
+  case 9: {
+    volatile long size = sizeof(x);
+    for (int i = 0; i < bench_niter; i++)
+      memset((void *)&x, i, size);
+    break;
+  }
+  case 10: {
+    volatile long data[2] = {};
+    volatile long size = sizeof(data) - 2;
+    for (int i = 0; i < bench_niter; i++)
+      memset(((char *)data) + 1, i, size);
+    break;
+  }
+  case 11: {
+    volatile long data[2] = {};
+    for (int i = 0; i < bench_niter / 8 / 3; i++) {
+      for (int off = 0; off < 8; off++) {
+        __sanitizer_unaligned_store16(((char *)data) + off, i);
+        __sanitizer_unaligned_store32(((char *)data) + off, i);
+        __sanitizer_unaligned_store64(((char *)data) + off, i);
+      }
+    }
+    break;
+  }
+  }
+}
+
+void bench() {
+  start_thread_group(bench_nthread, thread);
+}
+
+// CHECK: DONE