folly/test/BenchmarkTest.cpp

   1 /*
   2  * Copyright 2016 Facebook, Inc.
   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 <folly/Benchmark.h>
  18 #include <folly/Foreach.h>
  19 #include <folly/String.h>
  20 #include <algorithm>
  21 #include <iostream>
  22 #include <numeric>
  23 #include <random>
  24 #include <vector>
  25 using namespace folly;
  26 using namespace std;
  27
  28 void fun() {
  29   static double x = 1;
  30   ++x;
  31   doNotOptimizeAway(x);
  32 }
  33 BENCHMARK(bmFun) { fun(); }
  34 BENCHMARK(bmRepeatedFun, n) {
  35   FOR_EACH_RANGE (i, 0, n) {
  36     fun();
  37   }
  38 }
  39 BENCHMARK_DRAW_LINE()
  40
  41 BENCHMARK(gun) {
  42   static double x = 1;
  43   x *= 2000;
  44   doNotOptimizeAway(x);
  45 }
  46
  47 BENCHMARK_DRAW_LINE()
  48
  49 BENCHMARK(baselinevector) {
  50   vector<int> v;
  51
  52   BENCHMARK_SUSPEND {
  53     v.resize(1000);
  54   }
  55
  56   FOR_EACH_RANGE (i, 0, 100) {
  57     v.push_back(42);
  58   }
  59 }
  60
  61 BENCHMARK_RELATIVE(bmVector) {
  62   vector<int> v;
  63   FOR_EACH_RANGE (i, 0, 100) {
  64     v.resize(v.size() + 1, 42);
  65   }
  66 }
  67
  68 BENCHMARK_DRAW_LINE()
  69
  70 BENCHMARK(superslow) {
  71   sleep(1);
  72 }
  73
  74 BENCHMARK_DRAW_LINE()
  75
  76 BENCHMARK(noMulti) {
  77   fun();
  78 }
  79
  80 BENCHMARK_MULTI(multiSimple) {
  81   FOR_EACH_RANGE (i, 0, 10) {
  82     fun();
  83   }
  84   return 10;
  85 }
  86
  87 BENCHMARK_RELATIVE_MULTI(multiSimpleRel) {
  88   FOR_EACH_RANGE (i, 0, 10) {
  89     fun();
  90     fun();
  91   }
  92   return 10;
  93 }
  94
  95 BENCHMARK_MULTI(multiIterArgs, iter) {
  96   FOR_EACH_RANGE (i, 0, 10 * iter) {
  97     fun();
  98   }
  99   return 10 * iter;
 100 }
 101
 102 BENCHMARK_RELATIVE_MULTI(multiIterArgsRel, iter) {
 103   FOR_EACH_RANGE (i, 0, 10 * iter) {
 104     fun();
 105     fun();
 106   }
 107   return 10 * iter;
 108 }
 109
 110 unsigned paramMulti(unsigned iter, unsigned num) {
 111   for (unsigned i = 0; i < iter; ++i) {
 112     for (unsigned j = 0; j < num; ++j) {
 113       fun();
 114     }
 115   }
 116   return num * iter;
 117 }
 118
 119 unsigned paramMultiRel(unsigned iter, unsigned num) {
 120   for (unsigned i = 0; i < iter; ++i) {
 121     for (unsigned j = 0; j < num; ++j) {
 122       fun();
 123       fun();
 124     }
 125   }
 126   return num * iter;
 127 }
 128
 129 BENCHMARK_PARAM_MULTI(paramMulti, 1);
 130 BENCHMARK_RELATIVE_PARAM_MULTI(paramMultiRel, 1);
 131
 132 BENCHMARK_PARAM_MULTI(paramMulti, 5);
 133 BENCHMARK_RELATIVE_PARAM_MULTI(paramMultiRel, 5);
 134
 135 BENCHMARK_DRAW_LINE();
 136
 137 BENCHMARK(BenchmarkSuspender_dismissing_void, iter) {
 138   BenchmarkSuspender braces;
 139   mt19937_64 rng;
 140   while (iter--) {
 141     vector<size_t> v(1 << 12, 0);
 142     iota(v.begin(), v.end(), 0);
 143     shuffle(v.begin(), v.end(), rng);
 144     braces.dismissing([&] {
 145         sort(v.begin(), v.end());
 146     });
 147   }
 148 }
 149
 150 BENCHMARK(BenchmarkSuspender_dismissing_value, iter) {
 151   BenchmarkSuspender braces;
 152   mt19937_64 rng;
 153   while (iter--) {
 154     vector<size_t> v(1 << 12, 0);
 155     iota(v.begin(), v.end(), 0);
 156     shuffle(v.begin(), v.end(), rng);
 157     auto s = braces.dismissing([&] {
 158         sort(v.begin(), v.end());
 159         return accumulate(v.begin(), v.end(), 0, [](size_t a, size_t e) {
 160             return a + e;
 161         });
 162     });
 163     doNotOptimizeAway(s);
 164   }
 165 }
 166
 167 int main(int argc, char** argv) {
 168   gflags::ParseCommandLineFlags(&argc, &argv, true);
 169   runBenchmarks();
 170   runBenchmarksOnFlag();
 171 }