Switch bionic over to google-benchmark.
Also removes the old benchmarking library.
Change-Id: I4791ae69fa5dea03644d3d411c60b7c6d1fceae3
diff --git a/benchmarks/pthread_benchmark.cpp b/benchmarks/pthread_benchmark.cpp
index ad31e7e..bf4d6cb 100644
--- a/benchmarks/pthread_benchmark.cpp
+++ b/benchmarks/pthread_benchmark.cpp
@@ -16,218 +16,178 @@
#include <pthread.h>
-#include <benchmark/Benchmark.h>
+#include <benchmark/benchmark.h>
// Stop GCC optimizing out our pure function.
/* Must not be static! */ pthread_t (*pthread_self_fp)() = pthread_self;
-BENCHMARK_NO_ARG(BM_pthread_self);
-void BM_pthread_self::Run(int iters) {
- StartBenchmarkTiming();
-
- for (int i = 0; i < iters; ++i) {
+static void BM_pthread_self(benchmark::State& state) {
+ while (state.KeepRunning()) {
pthread_self_fp();
}
-
- StopBenchmarkTiming();
}
+BENCHMARK(BM_pthread_self);
-BENCHMARK_NO_ARG(BM_pthread_getspecific);
-void BM_pthread_getspecific::Run(int iters) {
- StopBenchmarkTiming();
+static void BM_pthread_getspecific(benchmark::State& state) {
pthread_key_t key;
pthread_key_create(&key, NULL);
- StartBenchmarkTiming();
- for (int i = 0; i < iters; ++i) {
+ while (state.KeepRunning()) {
pthread_getspecific(key);
}
- StopBenchmarkTiming();
pthread_key_delete(key);
}
+BENCHMARK(BM_pthread_getspecific);
-BENCHMARK_NO_ARG(BM_pthread_setspecific);
-void BM_pthread_setspecific::Run(int iters) {
- StopBenchmarkTiming();
+static void BM_pthread_setspecific(benchmark::State& state) {
pthread_key_t key;
pthread_key_create(&key, NULL);
- StartBenchmarkTiming();
- for (int i = 0; i < iters; ++i) {
+ while (state.KeepRunning()) {
pthread_setspecific(key, NULL);
}
- StopBenchmarkTiming();
pthread_key_delete(key);
}
+BENCHMARK(BM_pthread_setspecific);
static void DummyPthreadOnceInitFunction() {
}
-BENCHMARK_NO_ARG(BM_pthread_once);
-void BM_pthread_once::Run(int iters) {
- StopBenchmarkTiming();
+static void BM_pthread_once(benchmark::State& state) {
pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_once(&once, DummyPthreadOnceInitFunction);
- StartBenchmarkTiming();
- for (int i = 0; i < iters; ++i) {
+ while (state.KeepRunning()) {
pthread_once(&once, DummyPthreadOnceInitFunction);
}
-
- StopBenchmarkTiming();
}
+BENCHMARK(BM_pthread_once);
-BENCHMARK_NO_ARG(BM_pthread_mutex_lock);
-void BM_pthread_mutex_lock::Run(int iters) {
- StopBenchmarkTiming();
+static void BM_pthread_mutex_lock(benchmark::State& state) {
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
- StartBenchmarkTiming();
- for (int i = 0; i < iters; ++i) {
+ while (state.KeepRunning()) {
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
}
-
- StopBenchmarkTiming();
}
+BENCHMARK(BM_pthread_mutex_lock);
-BENCHMARK_NO_ARG(BM_pthread_mutex_lock_ERRORCHECK);
-void BM_pthread_mutex_lock_ERRORCHECK::Run(int iters) {
- StopBenchmarkTiming();
+static void BM_pthread_mutex_lock_ERRORCHECK(benchmark::State& state) {
pthread_mutex_t mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
- StartBenchmarkTiming();
- for (int i = 0; i < iters; ++i) {
+ while (state.KeepRunning()) {
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
}
-
- StopBenchmarkTiming();
}
+BENCHMARK(BM_pthread_mutex_lock_ERRORCHECK);
-BENCHMARK_NO_ARG(BM_pthread_mutex_lock_RECURSIVE);
-void BM_pthread_mutex_lock_RECURSIVE::Run(int iters) {
- StopBenchmarkTiming();
+static void BM_pthread_mutex_lock_RECURSIVE(benchmark::State& state) {
pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
- StartBenchmarkTiming();
- for (int i = 0; i < iters; ++i) {
+ while (state.KeepRunning()) {
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
}
-
- StopBenchmarkTiming();
}
+BENCHMARK(BM_pthread_mutex_lock_RECURSIVE);
-BENCHMARK_NO_ARG(BM_pthread_rwlock_read);
-void BM_pthread_rwlock_read::Run(int iters) {
- StopBenchmarkTiming();
+static void BM_pthread_rwlock_read(benchmark::State& state) {
pthread_rwlock_t lock;
pthread_rwlock_init(&lock, NULL);
- StartBenchmarkTiming();
- for (int i = 0; i < iters; ++i) {
+ while (state.KeepRunning()) {
pthread_rwlock_rdlock(&lock);
pthread_rwlock_unlock(&lock);
}
- StopBenchmarkTiming();
pthread_rwlock_destroy(&lock);
}
+BENCHMARK(BM_pthread_rwlock_read);
-BENCHMARK_NO_ARG(BM_pthread_rwlock_write);
-void BM_pthread_rwlock_write::Run(int iters) {
- StopBenchmarkTiming();
+static void BM_pthread_rwlock_write(benchmark::State& state) {
pthread_rwlock_t lock;
pthread_rwlock_init(&lock, NULL);
- StartBenchmarkTiming();
- for (int i = 0; i < iters; ++i) {
+ while (state.KeepRunning()) {
pthread_rwlock_wrlock(&lock);
pthread_rwlock_unlock(&lock);
}
- StopBenchmarkTiming();
pthread_rwlock_destroy(&lock);
}
+BENCHMARK(BM_pthread_rwlock_write);
static void* IdleThread(void*) {
return NULL;
}
-BENCHMARK_NO_ARG(BM_pthread_create);
-void BM_pthread_create::Run(int iters) {
- StopBenchmarkTiming();
- pthread_t thread;
-
- for (int i = 0; i < iters; ++i) {
- StartBenchmarkTiming();
+static void BM_pthread_create(benchmark::State& state) {
+ while (state.KeepRunning()) {
+ pthread_t thread;
pthread_create(&thread, NULL, IdleThread, NULL);
- StopBenchmarkTiming();
+ state.PauseTiming();
pthread_join(thread, NULL);
+ state.ResumeTiming();
}
}
+BENCHMARK(BM_pthread_create);
static void* RunThread(void* arg) {
- ::testing::Benchmark* benchmark = reinterpret_cast<::testing::Benchmark*>(arg);
- benchmark->StopBenchmarkTiming();
+ benchmark::State& state = *reinterpret_cast<benchmark::State*>(arg);
+ state.PauseTiming();
return NULL;
}
-BENCHMARK_NO_ARG(BM_pthread_create_and_run);
-void BM_pthread_create_and_run::Run(int iters) {
- StopBenchmarkTiming();
- pthread_t thread;
-
- for (int i = 0; i < iters; ++i) {
- StartBenchmarkTiming();
- pthread_create(&thread, NULL, RunThread, this);
+static void BM_pthread_create_and_run(benchmark::State& state) {
+ while (state.KeepRunning()) {
+ pthread_t thread;
+ pthread_create(&thread, NULL, RunThread, &state);
pthread_join(thread, NULL);
+ state.ResumeTiming();
}
}
+BENCHMARK(BM_pthread_create_and_run);
static void* ExitThread(void* arg) {
- ::testing::Benchmark* benchmark = reinterpret_cast<::testing::Benchmark*>(arg);
- benchmark->StartBenchmarkTiming();
+ benchmark::State& state = *reinterpret_cast<benchmark::State*>(arg);
+ state.ResumeTiming();
pthread_exit(NULL);
}
-BENCHMARK_NO_ARG(BM_pthread_exit_and_join);
-void BM_pthread_exit_and_join::Run(int iters) {
- StopBenchmarkTiming();
- pthread_t thread;
-
- for (int i = 0; i < iters; ++i) {
- pthread_create(&thread, NULL, ExitThread, this);
+static void BM_pthread_exit_and_join(benchmark::State& state) {
+ while (state.KeepRunning()) {
+ state.PauseTiming();
+ pthread_t thread;
+ pthread_create(&thread, NULL, ExitThread, &state);
pthread_join(thread, NULL);
- StopBenchmarkTiming();
}
}
+BENCHMARK(BM_pthread_exit_and_join);
-BENCHMARK_NO_ARG(BM_pthread_key_create);
-void BM_pthread_key_create::Run(int iters) {
- StopBenchmarkTiming();
- pthread_key_t key;
-
- for (int i = 0; i < iters; ++i) {
- StartBenchmarkTiming();
+static void BM_pthread_key_create(benchmark::State& state) {
+ while (state.KeepRunning()) {
+ pthread_key_t key;
pthread_key_create(&key, NULL);
- StopBenchmarkTiming();
+
+ state.PauseTiming();
+ pthread_key_delete(key);
+ state.ResumeTiming();
+ }
+}
+BENCHMARK(BM_pthread_key_create);
+
+static void BM_pthread_key_delete(benchmark::State& state) {
+ while (state.KeepRunning()) {
+ state.PauseTiming();
+ pthread_key_t key;
+ pthread_key_create(&key, NULL);
+ state.ResumeTiming();
+
pthread_key_delete(key);
}
}
-
-BENCHMARK_NO_ARG(BM_pthread_key_delete);
-void BM_pthread_key_delete::Run(int iters) {
- StopBenchmarkTiming();
- pthread_key_t key;
-
- for (int i = 0; i < iters; ++i) {
- pthread_key_create(&key, NULL);
- StartBenchmarkTiming();
- pthread_key_delete(key);
- StopBenchmarkTiming();
- }
-}
+BENCHMARK(BM_pthread_key_delete);