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
29 static uint64_t gBytesProcessed;
30 static uint64_t gBenchmarkTotalTimeNs;
31 static uint64_t gBenchmarkTotalTimeNsSquared;
32 static uint64_t gBenchmarkNum;
33 static uint64_t gBenchmarkStartTimeNs;
34
35 typedef std::vector< ::testing::Benchmark* > BenchmarkList;
36 static BenchmarkList* gBenchmarks;
37
Round(int n)38 static 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
NanoTime()52 static 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
59 namespace testing {
60
PrettyPrintInt(char * str,int len,unsigned int arg)61 int 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
ShouldRun(Benchmark * b,int argc,char * argv[])80 bool 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
BenchmarkRegister(Benchmark * b)101 void BenchmarkRegister(Benchmark* b) {
102 if (gBenchmarks == NULL) {
103 gBenchmarks = new BenchmarkList;
104 }
105 gBenchmarks->push_back(b);
106 }
107
RunRepeatedly(Benchmark * b,int iterations)108 void 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
Run(Benchmark * b)121 void 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
SetBenchmarkBytesProcessed(uint64_t x)174 void SetBenchmarkBytesProcessed(uint64_t x) {
175 gBytesProcessed = x;
176 }
177
ResetBenchmarkTiming()178 void ResetBenchmarkTiming() {
179 gBenchmarkStartTimeNs = 0;
180 gBenchmarkTotalTimeNs = 0;
181 gBenchmarkTotalTimeNsSquared = 0;
182 gBenchmarkNum = 0;
183 }
184
StopBenchmarkTiming(void)185 void 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
StartBenchmarkTiming(void)195 void StartBenchmarkTiming(void) {
196 if (gBenchmarkStartTimeNs == 0) {
197 gBenchmarkStartTimeNs = NanoTime();
198 }
199 }
200
StopBenchmarkTiming(uint64_t NanoTime)201 void 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
StartBenchmarkTiming(uint64_t NanoTime)213 void StartBenchmarkTiming(uint64_t NanoTime) {
214 if (gBenchmarkStartTimeNs == 0) {
215 gBenchmarkStartTimeNs = NanoTime;
216 }
217 }
218
main(int argc,char * argv[])219 int 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