summaryrefslogtreecommitdiffstats
path: root/liblog/tests/benchmark_main.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'liblog/tests/benchmark_main.cpp')
-rw-r--r--liblog/tests/benchmark_main.cpp245
1 files changed, 245 insertions, 0 deletions
diff --git a/liblog/tests/benchmark_main.cpp b/liblog/tests/benchmark_main.cpp
new file mode 100644
index 0000000..02df460
--- /dev/null
+++ b/liblog/tests/benchmark_main.cpp
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2012-2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <benchmark.h>
+
+#include <regex.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <string>
+#include <map>
+#include <vector>
+
+static uint64_t gBytesProcessed;
+static uint64_t gBenchmarkTotalTimeNs;
+static uint64_t gBenchmarkTotalTimeNsSquared;
+static uint64_t gBenchmarkNum;
+static uint64_t gBenchmarkStartTimeNs;
+
+typedef std::vector< ::testing::Benchmark* > BenchmarkList;
+static BenchmarkList* gBenchmarks;
+
+static int Round(int n) {
+ int base = 1;
+ while (base*10 < n) {
+ base *= 10;
+ }
+ if (n < 2*base) {
+ return 2*base;
+ }
+ if (n < 5*base) {
+ return 5*base;
+ }
+ return 10*base;
+}
+
+static uint64_t NanoTime() {
+ struct timespec t;
+ t.tv_sec = t.tv_nsec = 0;
+ clock_gettime(CLOCK_MONOTONIC, &t);
+ return static_cast<uint64_t>(t.tv_sec) * 1000000000ULL + t.tv_nsec;
+}
+
+namespace testing {
+
+int PrettyPrintInt(char* str, int len, unsigned int arg)
+{
+ if (arg >= (1<<30) && arg % (1<<30) == 0) {
+ return snprintf(str, len, "%uGi", arg/(1<<30));
+ } else if (arg >= (1<<20) && arg % (1<<20) == 0) {
+ return snprintf(str, len, "%uMi", arg/(1<<20));
+ } else if (arg >= (1<<10) && arg % (1<<10) == 0) {
+ return snprintf(str, len, "%uKi", arg/(1<<10));
+ } else if (arg >= 1000000000 && arg % 1000000000 == 0) {
+ return snprintf(str, len, "%uG", arg/1000000000);
+ } else if (arg >= 1000000 && arg % 1000000 == 0) {
+ return snprintf(str, len, "%uM", arg/1000000);
+ } else if (arg >= 1000 && arg % 1000 == 0) {
+ return snprintf(str, len, "%uK", arg/1000);
+ } else {
+ return snprintf(str, len, "%u", arg);
+ }
+}
+
+bool ShouldRun(Benchmark* b, int argc, char* argv[]) {
+ if (argc == 1) {
+ return true; // With no arguments, we run all benchmarks.
+ }
+ // Otherwise, we interpret each argument as a regular expression and
+ // see if any of our benchmarks match.
+ for (int i = 1; i < argc; i++) {
+ regex_t re;
+ if (regcomp(&re, argv[i], 0) != 0) {
+ fprintf(stderr, "couldn't compile \"%s\" as a regular expression!\n", argv[i]);
+ exit(EXIT_FAILURE);
+ }
+ int match = regexec(&re, b->Name(), 0, NULL, 0);
+ regfree(&re);
+ if (match != REG_NOMATCH) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void BenchmarkRegister(Benchmark* b) {
+ if (gBenchmarks == NULL) {
+ gBenchmarks = new BenchmarkList;
+ }
+ gBenchmarks->push_back(b);
+}
+
+void RunRepeatedly(Benchmark* b, int iterations) {
+ gBytesProcessed = 0;
+ ResetBenchmarkTiming();
+ uint64_t StartTimeNs = NanoTime();
+ b->RunFn(iterations);
+ // Catch us if we fail to log anything.
+ if ((gBenchmarkTotalTimeNs == 0)
+ && (StartTimeNs != 0)
+ && (gBenchmarkStartTimeNs == 0)) {
+ gBenchmarkTotalTimeNs = NanoTime() - StartTimeNs;
+ }
+}
+
+void Run(Benchmark* b) {
+ // run once in case it's expensive
+ unsigned iterations = 1;
+ uint64_t s = NanoTime();
+ RunRepeatedly(b, iterations);
+ s = NanoTime() - s;
+ while (s < 2e9 && gBenchmarkTotalTimeNs < 1e9 && iterations < 1e9) {
+ unsigned last = iterations;
+ if (gBenchmarkTotalTimeNs/iterations == 0) {
+ iterations = 1e9;
+ } else {
+ iterations = 1e9 / (gBenchmarkTotalTimeNs/iterations);
+ }
+ iterations = std::max(last + 1, std::min(iterations + iterations/2, 100*last));
+ iterations = Round(iterations);
+ s = NanoTime();
+ RunRepeatedly(b, iterations);
+ s = NanoTime() - s;
+ }
+
+ char throughput[100];
+ throughput[0] = '\0';
+ if (gBenchmarkTotalTimeNs > 0 && gBytesProcessed > 0) {
+ double mib_processed = static_cast<double>(gBytesProcessed)/1e6;
+ double seconds = static_cast<double>(gBenchmarkTotalTimeNs)/1e9;
+ snprintf(throughput, sizeof(throughput), " %8.2f MiB/s", mib_processed/seconds);
+ }
+
+ char full_name[100];
+ snprintf(full_name, sizeof(full_name), "%s%s%s", b->Name(),
+ b->ArgName() ? "/" : "",
+ b->ArgName() ? b->ArgName() : "");
+
+ uint64_t mean = gBenchmarkTotalTimeNs / iterations;
+ uint64_t sdev = 0;
+ if (gBenchmarkNum == iterations) {
+ mean = gBenchmarkTotalTimeNs / gBenchmarkNum;
+ uint64_t nXvariance = gBenchmarkTotalTimeNsSquared * gBenchmarkNum
+ - (gBenchmarkTotalTimeNs * gBenchmarkTotalTimeNs);
+ sdev = (sqrt((double)nXvariance) / gBenchmarkNum / gBenchmarkNum) + 0.5;
+ }
+ if (mean > (10000 * sdev)) {
+ printf("%-25s %10llu %10llu%s\n", full_name,
+ static_cast<uint64_t>(iterations), mean, throughput);
+ } else {
+ printf("%-25s %10llu %10llu(\317\203%llu)%s\n", full_name,
+ static_cast<uint64_t>(iterations), mean, sdev, throughput);
+ }
+ fflush(stdout);
+}
+
+} // namespace testing
+
+void SetBenchmarkBytesProcessed(uint64_t x) {
+ gBytesProcessed = x;
+}
+
+void ResetBenchmarkTiming() {
+ gBenchmarkStartTimeNs = 0;
+ gBenchmarkTotalTimeNs = 0;
+ gBenchmarkTotalTimeNsSquared = 0;
+ gBenchmarkNum = 0;
+}
+
+void StopBenchmarkTiming(void) {
+ if (gBenchmarkStartTimeNs != 0) {
+ int64_t diff = NanoTime() - gBenchmarkStartTimeNs;
+ gBenchmarkTotalTimeNs += diff;
+ gBenchmarkTotalTimeNsSquared += diff * diff;
+ ++gBenchmarkNum;
+ }
+ gBenchmarkStartTimeNs = 0;
+}
+
+void StartBenchmarkTiming(void) {
+ if (gBenchmarkStartTimeNs == 0) {
+ gBenchmarkStartTimeNs = NanoTime();
+ }
+}
+
+void StopBenchmarkTiming(uint64_t NanoTime) {
+ if (gBenchmarkStartTimeNs != 0) {
+ int64_t diff = NanoTime - gBenchmarkStartTimeNs;
+ gBenchmarkTotalTimeNs += diff;
+ gBenchmarkTotalTimeNsSquared += diff * diff;
+ if (NanoTime != 0) {
+ ++gBenchmarkNum;
+ }
+ }
+ gBenchmarkStartTimeNs = 0;
+}
+
+void StartBenchmarkTiming(uint64_t NanoTime) {
+ if (gBenchmarkStartTimeNs == 0) {
+ gBenchmarkStartTimeNs = NanoTime;
+ }
+}
+
+int main(int argc, char* argv[]) {
+ if (gBenchmarks->empty()) {
+ fprintf(stderr, "No benchmarks registered!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ bool need_header = true;
+ for (auto b : *gBenchmarks) {
+ if (ShouldRun(b, argc, argv)) {
+ if (need_header) {
+ printf("%-25s %10s %10s\n", "", "iterations", "ns/op");
+ fflush(stdout);
+ need_header = false;
+ }
+ Run(b);
+ }
+ }
+
+ if (need_header) {
+ fprintf(stderr, "No matching benchmarks!\n");
+ fprintf(stderr, "Available benchmarks:\n");
+ for (auto b : *gBenchmarks) {
+ fprintf(stderr, " %s\n", b->Name());
+ }
+ exit(EXIT_FAILURE);
+ }
+
+ return 0;
+}
generated by cgit v1.1 at 2025-01-24 23:59:47 +0000