Multithreaded tests are reenabled

include/benchmark/benchmark.h

@@ -129,6 +129,7 @@ static void BM_MultiThreaded(benchmark::State& state) {
     // Teardown code here.
   }
 }
+BENCHMARK(BM_MultiThreaded)->Threads(4);
 */
 
 #ifndef BENCHMARK_BENCHMARK_H_
@@ -137,6 +138,7 @@ static void BM_MultiThreaded(benchmark::State& state) {
 #include <stdint.h>
 
 #include <functional>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -226,6 +228,7 @@ class State {
  private:
   class FastClock;
   struct SharedState;
+  struct ThreadStats;
 
   State(FastClock* clock, SharedState* s, int t);
   bool StartRunning();
@@ -234,7 +237,10 @@ class State {
   void NewInterval();
   bool AllStarting();
 
+  static void* RunWrapper(void* arg);
   void Run();
+  void RunAsThread();
+  void Wait();
 
   enum EState {
     STATE_INITIAL,  // KeepRunning hasn't been called
@@ -242,7 +248,9 @@ class State {
     STATE_RUNNING,  // Running and being timed
     STATE_STOPPING, // Not being timed but waiting for other threads
     STATE_STOPPED,  // Stopped
-  } state_;
+  };
+
+  EState state_;
 
   FastClock* clock_;
 
@@ -250,6 +258,8 @@ class State {
   // BenchmarkInstance
   SharedState* shared_;
 
+  pthread_t thread_;
+
   // Custom label set by the user.
   std::string label_;
 
@@ -274,6 +284,8 @@ class State {
   // True if the current interval is the continuation of a previous one.
   bool is_continuation_;
 
+  std::unique_ptr<ThreadStats> stats_;
+
   friend class internal::Benchmark;
   DISALLOW_COPY_AND_ASSIGN(State);
 };
@@ -345,8 +357,7 @@ class Benchmark {
   // of some piece of code.
 
   // Run one instance of this benchmark concurrently in t threads.
-  // TODO(dominic): Allow multithreaded benchmarks
-  //Benchmark* Threads(int t);
+  Benchmark* Threads(int t);
 
   // Pick a set of values T from [min_threads,max_threads].
   // min_threads and max_threads are always included in T.  Run this
@@ -360,10 +371,10 @@ class Benchmark {
   //    Foo in 4 threads
   //    Foo in 8 threads
   //    Foo in 16 threads
-  // Benchmark* ThreadRange(int min_threads, int max_threads);
+  Benchmark* ThreadRange(int min_threads, int max_threads);
 
   // Equivalent to ThreadRange(NumCPUs(), NumCPUs())
-  //Benchmark* ThreadPerCpu();
+  Benchmark* ThreadPerCpu();
 
   // TODO(dominic): Control whether or not real-time is used for this benchmark
 
@@ -372,7 +383,6 @@ class Benchmark {
 
   // Used inside the benchmark implementation
   struct Instance;
-  struct ThreadStats;
 
   // Extract the list of benchmark instances that match the specified
   // regular expression.

include/benchmark/macros.h

@@ -36,6 +36,7 @@ char (&ArraySizeHelper(const T (&array)[N]))[N];
 
 #define CHECK(b) do { if (!(b)) assert(false); } while(0)
 #define CHECK_EQ(a, b) CHECK((a) == (b))
+#define CHECK_NE(a, b) CHECK((a) != (b))
 #define CHECK_GE(a, b) CHECK((a) >= (b))
 #define CHECK_LE(a, b) CHECK((a) <= (b))
 #define CHECK_GT(a, b) CHECK((a) > (b))

test/benchmark_test.cc

@@ -3,6 +3,7 @@
 #include <math.h>
 #include <stdint.h>
 
+#include <iostream>
 #include <limits>
 #include <list>
 #include <map>
@@ -33,7 +34,8 @@ std::set<int> ConstructRandomSet(int size) {
   return s;
 }
 
-static std::vector<int>* test_vector = NULL;
+pthread_mutex_t test_vector_mu;
+std::vector<int>* test_vector = nullptr;
 
 }  // end namespace
 
@@ -57,7 +59,7 @@ static void BM_CalculatePiRange(benchmark::State& state) {
   state.SetLabel(ss.str());
 }
 BENCHMARK_RANGE(BM_CalculatePiRange, 1, 1024 * 1024);
-/*
+
 static void BM_CalculatePi(benchmark::State& state) {
   static const int depth = 1024;
   double pi ATTRIBUTE_UNUSED = 0.0;
@@ -68,7 +70,7 @@ static void BM_CalculatePi(benchmark::State& state) {
 BENCHMARK(BM_CalculatePi)->Threads(8);
 BENCHMARK(BM_CalculatePi)->ThreadRange(1, 32);
 BENCHMARK(BM_CalculatePi)->ThreadPerCpu();
-*/
+
 static void BM_SetInsert(benchmark::State& state) {
   while (state.KeepRunning()) {
     state.PauseTiming();
@@ -107,16 +109,27 @@ static void BM_StringCompare(benchmark::State& state) {
 BENCHMARK(BM_StringCompare)->Range(1, 1<<20);
 
 static void BM_SetupTeardown(benchmark::State& state) {
-  if (state.thread_index == 0)
+  if (state.thread_index == 0) {
+    pthread_mutex_init(&test_vector_mu, nullptr);
+    // No need to lock test_vector_mu here as this is running single-threaded.
     test_vector = new std::vector<int>();
-  while (state.KeepRunning())
-    test_vector->push_back(0);
+  }
+  int i = 0;
+  while (state.KeepRunning()) {
+    pthread_mutex_lock(&test_vector_mu);
+    if (i%2 == 0)
+      test_vector->push_back(i);
+    else
+      test_vector->pop_back();
+    pthread_mutex_unlock(&test_vector_mu);
+    ++i;
+  }
   if (state.thread_index == 0) {
     delete test_vector;
-    test_vector = NULL;
+    pthread_mutex_destroy(&test_vector_mu);
   }
 }
-BENCHMARK(BM_SetupTeardown);
+BENCHMARK(BM_SetupTeardown)->ThreadPerCpu();
 
 static void BM_LongTest(benchmark::State& state) {
   double tracker = 0.0;