1/*
2 * Copyright (C) 2012-2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <benchmark.h>
18
19#include <inttypes.h>
20#include <math.h>
21#include <regex.h>
22#include <stdio.h>
23#include <stdlib.h>
24
25#include <string>
26#include <map>
27#include <vector>
28
29static uint64_t gBytesProcessed;
30static uint64_t gBenchmarkTotalTimeNs;
31static uint64_t gBenchmarkTotalTimeNsSquared;
32static uint64_t gBenchmarkNum;
33static uint64_t gBenchmarkStartTimeNs;
34
35typedef std::vector< ::testing::Benchmark* > BenchmarkList;
36static BenchmarkList* gBenchmarks;
37
38static int Round(int n) {
39  int base = 1;
40  while (base*10 < n) {
41    base *= 10;
42  }
43  if (n < 2*base) {
44    return 2*base;
45  }
46  if (n < 5*base) {
47    return 5*base;
48  }
49  return 10*base;
50}
51
52static uint64_t NanoTime() {
53  struct timespec t;
54  t.tv_sec = t.tv_nsec = 0;
55  clock_gettime(CLOCK_MONOTONIC, &t);
56  return static_cast<uint64_t>(t.tv_sec) * 1000000000ULL + t.tv_nsec;
57}
58
59namespace testing {
60
61int PrettyPrintInt(char* str, int len, unsigned int arg)
62{
63  if (arg >= (1<<30) && arg % (1<<30) == 0) {
64    return snprintf(str, len, "%uGi", arg/(1<<30));
65  } else if (arg >= (1<<20) && arg % (1<<20) == 0) {
66    return snprintf(str, len, "%uMi", arg/(1<<20));
67  } else if (arg >= (1<<10) && arg % (1<<10) == 0) {
68    return snprintf(str, len, "%uKi", arg/(1<<10));
69  } else if (arg >= 1000000000 && arg % 1000000000 == 0) {
70    return snprintf(str, len, "%uG", arg/1000000000);
71  } else if (arg >= 1000000 && arg % 1000000 == 0) {
72    return snprintf(str, len, "%uM", arg/1000000);
73  } else if (arg >= 1000 && arg % 1000 == 0) {
74    return snprintf(str, len, "%uK", arg/1000);
75  } else {
76    return snprintf(str, len, "%u", arg);
77  }
78}
79
80bool ShouldRun(Benchmark* b, int argc, char* argv[]) {
81  if (argc == 1) {
82    return true;  // With no arguments, we run all benchmarks.
83  }
84  // Otherwise, we interpret each argument as a regular expression and
85  // see if any of our benchmarks match.
86  for (int i = 1; i < argc; i++) {
87    regex_t re;
88    if (regcomp(&re, argv[i], 0) != 0) {
89      fprintf(stderr, "couldn't compile \"%s\" as a regular expression!\n", argv[i]);
90      exit(EXIT_FAILURE);
91    }
92    int match = regexec(&re, b->Name(), 0, NULL, 0);
93    regfree(&re);
94    if (match != REG_NOMATCH) {
95      return true;
96    }
97  }
98  return false;
99}
100
101void BenchmarkRegister(Benchmark* b) {
102  if (gBenchmarks == NULL) {
103    gBenchmarks = new BenchmarkList;
104  }
105  gBenchmarks->push_back(b);
106}
107
108void RunRepeatedly(Benchmark* b, int iterations) {
109  gBytesProcessed = 0;
110  ResetBenchmarkTiming();
111  uint64_t StartTimeNs = NanoTime();
112  b->RunFn(iterations);
113  // Catch us if we fail to log anything.
114  if ((gBenchmarkTotalTimeNs == 0)
115   && (StartTimeNs != 0)
116   && (gBenchmarkStartTimeNs == 0)) {
117    gBenchmarkTotalTimeNs = NanoTime() - StartTimeNs;
118  }
119}
120
121void Run(Benchmark* b) {
122  // run once in case it's expensive
123  unsigned iterations = 1;
124  uint64_t s = NanoTime();
125  RunRepeatedly(b, iterations);
126  s = NanoTime() - s;
127  while (s < 2e9 && gBenchmarkTotalTimeNs < 1e9 && iterations < 1e9) {
128    unsigned last = iterations;
129    if (gBenchmarkTotalTimeNs/iterations == 0) {
130      iterations = 1e9;
131    } else {
132      iterations = 1e9 / (gBenchmarkTotalTimeNs/iterations);
133    }
134    iterations = std::max(last + 1, std::min(iterations + iterations/2, 100*last));
135    iterations = Round(iterations);
136    s = NanoTime();
137    RunRepeatedly(b, iterations);
138    s = NanoTime() - s;
139  }
140
141  char throughput[100];
142  throughput[0] = '\0';
143  if (gBenchmarkTotalTimeNs > 0 && gBytesProcessed > 0) {
144    double mib_processed = static_cast<double>(gBytesProcessed)/1e6;
145    double seconds = static_cast<double>(gBenchmarkTotalTimeNs)/1e9;
146    snprintf(throughput, sizeof(throughput), " %8.2f MiB/s", mib_processed/seconds);
147  }
148
149  char full_name[100];
150  snprintf(full_name, sizeof(full_name), "%s%s%s", b->Name(),
151           b->ArgName() ? "/" : "",
152           b->ArgName() ? b->ArgName() : "");
153
154  uint64_t mean = gBenchmarkTotalTimeNs / iterations;
155  uint64_t sdev = 0;
156  if (gBenchmarkNum == iterations) {
157    mean = gBenchmarkTotalTimeNs / gBenchmarkNum;
158    uint64_t nXvariance = gBenchmarkTotalTimeNsSquared * gBenchmarkNum
159                        - (gBenchmarkTotalTimeNs * gBenchmarkTotalTimeNs);
160    sdev = (sqrt((double)nXvariance) / gBenchmarkNum / gBenchmarkNum) + 0.5;
161  }
162  if (mean > (10000 * sdev)) {
163    printf("%-25s %10" PRIu64 " %10" PRIu64 "%s\n", full_name,
164            static_cast<uint64_t>(iterations), mean, throughput);
165  } else {
166    printf("%-25s %10" PRIu64 " %10" PRIu64 "(\317\203%" PRIu64 ")%s\n", full_name,
167           static_cast<uint64_t>(iterations), mean, sdev, throughput);
168  }
169  fflush(stdout);
170}
171
172}  // namespace testing
173
174void SetBenchmarkBytesProcessed(uint64_t x) {
175  gBytesProcessed = x;
176}
177
178void ResetBenchmarkTiming() {
179  gBenchmarkStartTimeNs = 0;
180  gBenchmarkTotalTimeNs = 0;
181  gBenchmarkTotalTimeNsSquared = 0;
182  gBenchmarkNum = 0;
183}
184
185void StopBenchmarkTiming(void) {
186  if (gBenchmarkStartTimeNs != 0) {
187    int64_t diff = NanoTime() - gBenchmarkStartTimeNs;
188    gBenchmarkTotalTimeNs += diff;
189    gBenchmarkTotalTimeNsSquared += diff * diff;
190    ++gBenchmarkNum;
191  }
192  gBenchmarkStartTimeNs = 0;
193}
194
195void StartBenchmarkTiming(void) {
196  if (gBenchmarkStartTimeNs == 0) {
197    gBenchmarkStartTimeNs = NanoTime();
198  }
199}
200
201void StopBenchmarkTiming(uint64_t NanoTime) {
202  if (gBenchmarkStartTimeNs != 0) {
203    int64_t diff = NanoTime - gBenchmarkStartTimeNs;
204    gBenchmarkTotalTimeNs += diff;
205    gBenchmarkTotalTimeNsSquared += diff * diff;
206    if (NanoTime != 0) {
207      ++gBenchmarkNum;
208    }
209  }
210  gBenchmarkStartTimeNs = 0;
211}
212
213void StartBenchmarkTiming(uint64_t NanoTime) {
214  if (gBenchmarkStartTimeNs == 0) {
215    gBenchmarkStartTimeNs = NanoTime;
216  }
217}
218
219int main(int argc, char* argv[]) {
220  if (gBenchmarks->empty()) {
221    fprintf(stderr, "No benchmarks registered!\n");
222    exit(EXIT_FAILURE);
223  }
224
225  bool need_header = true;
226  for (auto b : *gBenchmarks) {
227    if (ShouldRun(b, argc, argv)) {
228      if (need_header) {
229        printf("%-25s %10s %10s\n", "", "iterations", "ns/op");
230        fflush(stdout);
231        need_header = false;
232      }
233      Run(b);
234    }
235  }
236
237  if (need_header) {
238    fprintf(stderr, "No matching benchmarks!\n");
239    fprintf(stderr, "Available benchmarks:\n");
240    for (auto b : *gBenchmarks) {
241      fprintf(stderr, "  %s\n", b->Name());
242    }
243    exit(EXIT_FAILURE);
244  }
245
246  return 0;
247}
248