2 * Copyright 2012 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 // @author Andrei Alexandrescu (andrei.alexandrescu@fb.com)
19 #include "Benchmark.h"
25 #include <boost/regex.hpp>
34 DEFINE_bool(benchmark, false, "Run benchmarks.");
35 DEFINE_bool(json, false, "Output in JSON format.");
37 DEFINE_string(bm_regex, "",
38 "Only benchmarks whose names match this regex will be run.");
40 DEFINE_int64(bm_min_usec, 100,
41 "Minimum # of microseconds we'll accept for each benchmark.");
43 DEFINE_int32(bm_max_secs, 1,
44 "Maximum # of seconds we'll spend on each benchmark.");
49 BenchmarkSuspender::NanosecondsSpent BenchmarkSuspender::nsSpent;
51 typedef function<uint64_t(unsigned int)> BenchmarkFun;
52 static vector<tuple<const char*, const char*, BenchmarkFun>> benchmarks;
54 // Add the global baseline
55 BENCHMARK(globalBenchmarkBaseline) {
59 void detail::addBenchmarkImpl(const char* file, const char* name,
61 benchmarks.emplace_back(file, name, std::move(fun));
65 * Given a point, gives density at that point as a number 0.0 < x <=
66 * 1.0. The result is 1.0 if all samples are equal to where, and
67 * decreases near 0 if all points are far away from it. The density is
68 * computed with the help of a radial basis function.
70 static double density(const double * begin, const double *const end,
71 const double where, const double bandwidth) {
73 assert(bandwidth > 0.0);
75 FOR_EACH_RANGE (i, begin, end) {
76 auto d = (*i - where) / bandwidth;
79 return sum / (end - begin);
83 * Computes mean and variance for a bunch of data points. Note that
84 * mean is currently not being used.
86 static pair<double, double>
87 meanVariance(const double * begin, const double *const end) {
89 double sum = 0.0, sum2 = 0.0;
90 FOR_EACH_RANGE (i, begin, end) {
94 auto const n = end - begin;
95 return make_pair(sum / n, sqrt((sum2 - sum * sum / n) / n));
99 * Computes the mode of a sample set through brute force. Assumes
102 static double mode(const double * begin, const double *const end) {
104 // Lower bound and upper bound for result and their respective
110 // Get the variance so we pass it down to density()
111 auto const sigma = meanVariance(begin, end).second;
113 // No variance means constant signal
117 FOR_EACH_RANGE (i, begin, end) {
118 assert(i == begin || *i >= i[-1]);
119 auto candidate = density(begin, end, *i, sigma * sqrt(2.0));
120 if (candidate > bestDensity) {
122 bestDensity = candidate;
125 // Density is decreasing... we could break here if we definitely
126 // knew this is unimodal.
134 * Given a bunch of benchmark samples, estimate the actual run time.
136 static double estimateTime(double * begin, double * end) {
139 // Current state of the art: get the minimum. After some
140 // experimentation, it seems taking the minimum is the best.
142 return *min_element(begin, end);
144 // What follows after estimates the time as the mode of the
147 // Select the awesomest (i.e. most frequent) result. We do this by
148 // sorting and then computing the longest run length.
151 // Eliminate outliers. A time much larger than the minimum time is
152 // considered an outlier.
153 while (end[-1] > 2.0 * *begin) {
163 /* Code used just for comparison purposes */ {
164 unsigned bestFrequency = 0;
165 unsigned candidateFrequency = 1;
166 double candidateValue = *begin;
167 for (auto current = begin + 1; ; ++current) {
168 if (current == end || *current != candidateValue) {
169 // Done with the current run, see if it was best
170 if (candidateFrequency > bestFrequency) {
171 bestFrequency = candidateFrequency;
172 result = candidateValue;
174 if (current == end) {
178 candidateValue = *current;
179 candidateFrequency = 1;
181 // Cool, inside a run, increase the frequency
182 ++candidateFrequency;
187 result = mode(begin, end);
192 static double runBenchmarkGetNSPerIteration(const BenchmarkFun& fun,
193 const double globalBaseline) {
194 // They key here is accuracy; too low numbers means the accuracy was
195 // coarse. We up the ante until we get to at least minNanoseconds
197 static uint64_t resolutionInNs = 0, coarseResolutionInNs = 0;
198 if (!resolutionInNs) {
200 CHECK_EQ(0, clock_getres(detail::DEFAULT_CLOCK_ID, &ts));
201 CHECK_EQ(0, ts.tv_sec) << "Clock sucks.";
202 CHECK_LT(0, ts.tv_nsec) << "Clock too fast for its own good.";
203 CHECK_EQ(1, ts.tv_nsec) << "Clock too coarse, upgrade your kernel.";
204 resolutionInNs = ts.tv_nsec;
206 // We choose a minimum minimum (sic) of 100,000 nanoseconds, but if
207 // the clock resolution is worse than that, it will be larger. In
208 // essence we're aiming at making the quantization noise 0.01%.
209 static const auto minNanoseconds =
210 max(FLAGS_bm_min_usec * 1000UL, min(resolutionInNs * 100000, 1000000000UL));
212 // We do measurements in several epochs and take the minimum, to
213 // account for jitter.
214 static const unsigned int epochs = 1000;
215 // We establish a total time budget as we don't want a measurement
216 // to take too long. This will curtail the number of actual epochs.
217 const uint64_t timeBudgetInNs = FLAGS_bm_max_secs * 1000000000;
219 CHECK_EQ(0, clock_gettime(CLOCK_REALTIME, &global));
221 double epochResults[epochs] = { 0 };
222 size_t actualEpochs = 0;
224 for (; actualEpochs < epochs; ++actualEpochs) {
225 for (unsigned int n = 1; n < (1UL << 30); n *= 2) {
226 auto const nsecs = fun(n);
227 if (nsecs < minNanoseconds) {
230 // We got an accurate enough timing, done. But only save if
231 // smaller than the current result.
232 epochResults[actualEpochs] = max(0.0, double(nsecs) / n - globalBaseline);
233 // Done with the current epoch, we got a meaningful timing.
237 CHECK_EQ(0, clock_gettime(CLOCK_REALTIME, &now));
238 if (detail::timespecDiff(now, global) >= timeBudgetInNs) {
239 // No more time budget available.
245 // If the benchmark was basically drowned in baseline noise, it's
246 // possible it became negative.
247 return max(0.0, estimateTime(epochResults, epochResults + actualEpochs));
255 static const ScaleInfo kTimeSuffixes[] {
256 { 365.25 * 24 * 3600, "years" },
257 { 24 * 3600, "days" },
269 static const ScaleInfo kMetricSuffixes[] {
270 { 1E24, "Y" }, // yotta
271 { 1E21, "Z" }, // zetta
272 { 1E18, "X" }, // "exa" written with suffix 'X' so as to not create
273 // confusion with scientific notation
274 { 1E15, "P" }, // peta
275 { 1E12, "T" }, // terra
276 { 1E9, "G" }, // giga
277 { 1E6, "M" }, // mega
278 { 1E3, "K" }, // kilo
280 { 1E-3, "m" }, // milli
281 { 1E-6, "u" }, // micro
282 { 1E-9, "n" }, // nano
283 { 1E-12, "p" }, // pico
284 { 1E-15, "f" }, // femto
285 { 1E-18, "a" }, // atto
286 { 1E-21, "z" }, // zepto
287 { 1E-24, "y" }, // yocto
291 static string humanReadable(double n, unsigned int decimals,
292 const ScaleInfo* scales) {
293 if (std::isinf(n) || std::isnan(n)) {
294 return folly::to<string>(n);
297 const double absValue = fabs(n);
298 const ScaleInfo* scale = scales;
299 while (absValue < scale[0].boundary && scale[1].suffix != NULL) {
303 const double scaledValue = n / scale->boundary;
304 return stringPrintf("%.*f%s", decimals, scaledValue, scale->suffix);
307 static string readableTime(double n, unsigned int decimals) {
308 return humanReadable(n, decimals, kTimeSuffixes);
311 static string metricReadable(double n, unsigned int decimals) {
312 return humanReadable(n, decimals, kMetricSuffixes);
315 static void printBenchmarkResultsAsTable(
316 const vector<tuple<const char*, const char*, double> >& data) {
318 static const uint columns = 76;
320 // Compute the longest benchmark name
321 size_t longestName = 0;
322 FOR_EACH_RANGE (i, 1, benchmarks.size()) {
323 longestName = max(longestName, strlen(get<1>(benchmarks[i])));
326 // Print a horizontal rule
327 auto separator = [&](char pad) {
328 puts(string(columns, pad).c_str());
331 // Print header for a file
332 auto header = [&](const char* file) {
334 printf("%-*srelative time/iter iters/s\n",
339 double baselineNsPerIter = numeric_limits<double>::max();
340 const char* lastFile = "";
342 for (auto& datum : data) {
343 auto file = get<0>(datum);
344 if (strcmp(file, lastFile)) {
350 string s = get<1>(datum);
355 bool useBaseline /* = void */;
360 baselineNsPerIter = get<2>(datum);
363 s.resize(columns - 29, ' ');
364 auto nsPerIter = get<2>(datum);
365 auto secPerIter = nsPerIter / 1E9;
366 auto itersPerSec = 1 / secPerIter;
368 // Print without baseline
369 printf("%*s %9s %7s\n",
370 static_cast<int>(s.size()), s.c_str(),
371 readableTime(secPerIter, 2).c_str(),
372 metricReadable(itersPerSec, 2).c_str());
374 // Print with baseline
375 auto rel = baselineNsPerIter / nsPerIter * 100.0;
376 printf("%*s %7.2f%% %9s %7s\n",
377 static_cast<int>(s.size()), s.c_str(),
379 readableTime(secPerIter, 2).c_str(),
380 metricReadable(itersPerSec, 2).c_str());
386 static void printBenchmarkResultsAsJson(
387 const vector<tuple<const char*, const char*, double> >& data) {
388 dynamic d = dynamic::object;
389 for (auto& datum: data) {
390 d[std::get<1>(datum)] = std::get<2>(datum) * 1000.;
393 printf("%s\n", toPrettyJson(d).c_str());
396 static void printBenchmarkResults(
397 const vector<tuple<const char*, const char*, double> >& data) {
400 printBenchmarkResultsAsJson(data);
402 printBenchmarkResultsAsTable(data);
406 void runBenchmarks() {
407 CHECK(!benchmarks.empty());
409 vector<tuple<const char*, const char*, double>> results;
410 results.reserve(benchmarks.size() - 1);
412 std::unique_ptr<boost::regex> bmRegex;
413 if (!FLAGS_bm_regex.empty()) {
414 bmRegex.reset(new boost::regex(FLAGS_bm_regex));
417 // PLEASE KEEP QUIET. MEASUREMENTS IN PROGRESS.
419 auto const globalBaseline = runBenchmarkGetNSPerIteration(
420 get<2>(benchmarks.front()), 0);
421 FOR_EACH_RANGE (i, 1, benchmarks.size()) {
422 double elapsed = 0.0;
423 if (!strcmp(get<1>(benchmarks[i]), "-") == 0) { // skip separators
424 if (bmRegex && !boost::regex_search(get<1>(benchmarks[i]), *bmRegex)) {
427 elapsed = runBenchmarkGetNSPerIteration(get<2>(benchmarks[i]),
430 results.emplace_back(get<0>(benchmarks[i]),
431 get<1>(benchmarks[i]), elapsed);
434 // PLEASE MAKE NOISE. MEASUREMENTS DONE.
436 printBenchmarkResults(results);