BenchmarkTest.cpp File Reference

#include <folly/Benchmark.h>
#include <folly/String.h>
#include <folly/container/Foreach.h>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <random>
#include <vector>

Go to the source code of this file.

Functions
void	fun ()
	BENCHMARK (bmFun)
	BENCHMARK (bmRepeatedFun, n)
	BENCHMARK_DRAW_LINE ()
	BENCHMARK (gun)
	BENCHMARK (optimizerCanDiscardTrivial, n)
	BENCHMARK (optimizerCanPowerReduceInner1Trivial, n)
	BENCHMARK (optimizerCanPowerReduceInner2Trivial, n)
	BENCHMARK (optimizerDisabled1Trivial, n)
	BENCHMARK (optimizerDisabled2Trivial, n)
	BENCHMARK (optimizerCanPowerReduceInner1TrivialPtr, n)
	BENCHMARK (optimizerCanPowerReduceInner2TrivialPtr, n)
	BENCHMARK (optimizerDisabled1TrivialPtr, n)
	BENCHMARK (optimizerCanDiscardNonTrivial, n)
	BENCHMARK (optimizerCanPowerReduceInner1NonTrivial, n)
	BENCHMARK (optimizerCanPowerReduceInner2NonTrivial, n)
	BENCHMARK (optimizerDisabled1NonTrivial, n)
	BENCHMARK (optimizerDisabled2NonTrivial, n)
	BENCHMARK (optimizerCanPowerReduceInner1NonTrivialPtr, n)
	BENCHMARK (optimizerCanPowerReduceInner2NonTrivialPtr, n)
	BENCHMARK (optimizerDisabled1NonTrivialPtr, n)
	BENCHMARK (baselinevector)
	BENCHMARK_RELATIVE (bmVector)
	BENCHMARK (superslow)
	BENCHMARK (noMulti)
	BENCHMARK_MULTI (multiSimple)
	BENCHMARK_RELATIVE_MULTI (multiSimpleRel)
	BENCHMARK_MULTI (multiIterArgs, iter)
	BENCHMARK_RELATIVE_MULTI (multiIterArgsRel, iter)
unsigned	paramMulti (unsigned iter, unsigned num)
unsigned	paramMultiRel (unsigned iter, unsigned num)
	BENCHMARK (BenchmarkSuspender_dismissing_void, iter)
	BENCHMARK (BenchmarkSuspender_dismissing_value, iter)
int	main (int argc, char **argv)

Function Documentation

BENCHMARK

(

bmFun

)

Definition at line 33 of file BenchmarkTest.cpp.

References fun().

                 {
  fun();
}

BENCHMARK	(	bmRepeatedFun	,
		n
	)

Definition at line 36 of file BenchmarkTest.cpp.

References folly::BENCHMARK_DRAW_LINE(), FOR_EACH_RANGE, fun(), and i.

                            {
  FOR_EACH_RANGE (i, 0, n) { fun(); }
}

BENCHMARK

(

gun

)

Definition at line 41 of file BenchmarkTest.cpp.

References folly::BENCHMARK_DRAW_LINE(), and folly::doNotOptimizeAway().

               {
  static double x = 1;
  x *= 2000;
  doNotOptimizeAway(x);
}

BENCHMARK	(	optimizerCanDiscardTrivial	,
		n
	)

Definition at line 49 of file BenchmarkTest.cpp.

References i.

                                         {
  long x = 0;
  for (long i = 0; i < n; ++i) {
    for (long j = 0; j < 10000; ++j) {
      x += j;
    }
  }
}

BENCHMARK	(	optimizerCanPowerReduceInner1Trivial	,
		n
	)

Definition at line 58 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), and i.

                                                   {
  long x = 0;
  for (long i = 0; i < n; ++i) {
    for (long j = 0; j < 10000; ++j) {
      x += i + j;
    }
    doNotOptimizeAway(x);
  }
}

BENCHMARK	(	optimizerCanPowerReduceInner2Trivial	,
		n
	)

Definition at line 68 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, and folly::makeUnpredictable().

                                                   {
  long x = 0;
  for (long i = 0; i < n; ++i) {
    makeUnpredictable(i);
    for (long j = 0; j < 10000; ++j) {
      x += i + j;
    }
  }
  doNotOptimizeAway(x);
}

BENCHMARK	(	optimizerDisabled1Trivial	,
		n
	)

Definition at line 79 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), and i.

                                        {
  long x = 0;
  for (long i = 0; i < n; ++i) {
    for (long j = 0; j < 10000; ++j) {
      x += i + j;
      doNotOptimizeAway(x);
    }
  }
}

BENCHMARK	(	optimizerDisabled2Trivial	,
		n
	)

Definition at line 89 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, and folly::makeUnpredictable().

                                        {
  long x = 0;
  for (long i = 0; i < n; ++i) {
    makeUnpredictable(i);
    for (long j = 0; j < 10000; ++j) {
      makeUnpredictable(j);
      x += i + j;
    }
  }
  doNotOptimizeAway(x);
}

BENCHMARK	(	optimizerCanPowerReduceInner1TrivialPtr	,
		n
	)

Definition at line 101 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), and i.

                                                      {
  long x = 0;
  for (long i = 0; i < n; ++i) {
    for (long j = 0; j < 10000; ++j) {
      x += i + j;
    }
    doNotOptimizeAway(&x);
  }
}

BENCHMARK	(	optimizerCanPowerReduceInner2TrivialPtr	,
		n
	)

Definition at line 111 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, and folly::makeUnpredictable().

                                                      {
  long x = 0;
  for (long i = 0; i < n; ++i) {
    makeUnpredictable(i);
    for (long j = 0; j < 10000; ++j) {
      x += i + j;
    }
  }
  doNotOptimizeAway(&x);
}

BENCHMARK	(	optimizerDisabled1TrivialPtr	,
		n
	)

Definition at line 122 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, folly::operator+(), folly::operator+=(), folly::operator<(), and folly::detail::rhs.

                                           {
  long x = 0;
  for (long i = 0; i < n; ++i) {
    for (long j = 0; j < 10000; ++j) {
      x += i + j;
      doNotOptimizeAway(&x);
    }
  }
}

BENCHMARK	(	optimizerCanDiscardNonTrivial	,
		n
	)

Definition at line 160 of file BenchmarkTest.cpp.

References i, and x.

                                            {
  NonTrivialLong x(0);
  for (NonTrivialLong i(0); i < n; ++i) {
    for (NonTrivialLong j(0); j < 10000; ++j) {
      x += j;
    }
  }
}

BENCHMARK	(	optimizerCanPowerReduceInner1NonTrivial	,
		n
	)

Definition at line 169 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, and x.

                                                      {
  NonTrivialLong x(0);
  for (NonTrivialLong i(0); i < n; ++i) {
    for (NonTrivialLong j(0); j < 10000; ++j) {
      x += i + j;
    }
    doNotOptimizeAway(x);
  }
}

BENCHMARK	(	optimizerCanPowerReduceInner2NonTrivial	,
		n
	)

Definition at line 179 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, folly::makeUnpredictable(), and x.

                                                      {
  NonTrivialLong x(0);
  for (NonTrivialLong i(0); i < n; ++i) {
    makeUnpredictable(i);
    for (NonTrivialLong j(0); j < 10000; ++j) {
      x += i + j;
    }
  }
  doNotOptimizeAway(x);
}

BENCHMARK	(	optimizerDisabled1NonTrivial	,
		n
	)

Definition at line 190 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, and x.

                                           {
  NonTrivialLong x(0);
  for (NonTrivialLong i(0); i < n; ++i) {
    for (NonTrivialLong j(0); j < 10000; ++j) {
      x += i + j;
      doNotOptimizeAway(x);
    }
  }
}

BENCHMARK	(	optimizerDisabled2NonTrivial	,
		n
	)

Definition at line 200 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, folly::makeUnpredictable(), and x.

                                           {
  NonTrivialLong x(0);
  for (NonTrivialLong i(0); i < n; ++i) {
    makeUnpredictable(i);
    for (NonTrivialLong j(0); j < 10000; ++j) {
      makeUnpredictable(j);
      x += i + j;
    }
  }
  doNotOptimizeAway(x);
}

BENCHMARK	(	optimizerCanPowerReduceInner1NonTrivialPtr	,
		n
	)

Definition at line 212 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, and x.

                                                         {
  NonTrivialLong x(0);
  for (NonTrivialLong i(0); i < n; ++i) {
    for (NonTrivialLong j(0); j < 10000; ++j) {
      x += i + j;
    }
    doNotOptimizeAway(&x);
  }
}

BENCHMARK	(	optimizerCanPowerReduceInner2NonTrivialPtr	,
		n
	)

Definition at line 222 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), i, folly::makeUnpredictable(), and x.

                                                         {
  NonTrivialLong x(0);
  for (NonTrivialLong i(0); i < n; ++i) {
    makeUnpredictable(i);
    for (NonTrivialLong j(0); j < 10000; ++j) {
      x += i + j;
    }
  }
  doNotOptimizeAway(&x);
}

BENCHMARK	(	optimizerDisabled1NonTrivialPtr	,
		n
	)

Definition at line 233 of file BenchmarkTest.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), i, and x.

                                              {
  NonTrivialLong x(0);
  for (NonTrivialLong i(0); i < n; ++i) {
    for (NonTrivialLong j(0); j < 10000; ++j) {
      x += i + j;
      doNotOptimizeAway(&x);
    }
  }
}

BENCHMARK

(

baselinevector

)

Definition at line 245 of file BenchmarkTest.cpp.

References BENCHMARK_SUSPEND, FOR_EACH_RANGE, i, and v.

                          {
  vector<int> v;

  BENCHMARK_SUSPEND {
    v.resize(1000);
  }

  FOR_EACH_RANGE (i, 0, 100) { v.push_back(42); }
}

BENCHMARK

(

superslow

)

Definition at line 262 of file BenchmarkTest.cpp.

References folly::BENCHMARK_DRAW_LINE(), and folly::futures::sleep().

                     {
  sleep(1);
}

BENCHMARK

(

noMulti

)

Definition at line 268 of file BenchmarkTest.cpp.

References fun().

                   {
  fun();
}

BENCHMARK	(	BenchmarkSuspender_dismissing_void	,
		iter
	)

Definition at line 325 of file BenchmarkTest.cpp.

References folly::BenchmarkSuspender::dismissing(), rng, and v.

                                                    {
  BenchmarkSuspender braces;
  mt19937_64 rng;
  while (iter--) {
    vector<size_t> v(1 << 12, 0);
    iota(v.begin(), v.end(), 0);
    shuffle(v.begin(), v.end(), rng);
    braces.dismissing([&] { sort(v.begin(), v.end()); });
  }
}

BENCHMARK	(	BenchmarkSuspender_dismissing_value	,
		iter
	)

Definition at line 336 of file BenchmarkTest.cpp.

References a, folly::f14::accumulate(), folly::BenchmarkSuspender::dismissing(), folly::doNotOptimizeAway(), rng, s, and v.

                                                     {
  BenchmarkSuspender braces;
  mt19937_64 rng;
  while (iter--) {
    vector<size_t> v(1 << 12, 0);
    iota(v.begin(), v.end(), 0);
    shuffle(v.begin(), v.end(), rng);
    auto s = braces.dismissing([&] {
      sort(v.begin(), v.end());
      return accumulate(
          v.begin(), v.end(), 0, [](size_t a, size_t e) { return a + e; });
    });
    doNotOptimizeAway(s);
  }
}

BENCHMARK_DRAW_LINE

(

)

BENCHMARK_MULTI

(

multiSimple

)

Definition at line 272 of file BenchmarkTest.cpp.

References FOR_EACH_RANGE, fun(), and i.

                             {
  FOR_EACH_RANGE (i, 0, 10) { fun(); }
  return 10;
}

BENCHMARK_MULTI	(	multiIterArgs	,
		iter
	)

Definition at line 285 of file BenchmarkTest.cpp.

References FOR_EACH_RANGE, fun(), and i.

                                     {
  FOR_EACH_RANGE (i, 0, 10 * iter) { fun(); }
  return 10 * iter;
}

BENCHMARK_RELATIVE

(

bmVector

)

Definition at line 255 of file BenchmarkTest.cpp.

References folly::BENCHMARK_DRAW_LINE(), FOR_EACH_RANGE, i, and v.

                             {
  vector<int> v;
  FOR_EACH_RANGE (i, 0, 100) { v.resize(v.size() + 1, 42); }
}

BENCHMARK_RELATIVE_MULTI

(

multiSimpleRel

)

Definition at line 277 of file BenchmarkTest.cpp.

References FOR_EACH_RANGE, fun(), and i.

                                         {
  FOR_EACH_RANGE (i, 0, 10) {
    fun();
    fun();
  }
  return 10;
}

BENCHMARK_RELATIVE_MULTI	(	multiIterArgsRel	,
		iter
	)

Definition at line 290 of file BenchmarkTest.cpp.

References FOR_EACH_RANGE, fun(), and i.

                                                 {
  FOR_EACH_RANGE (i, 0, 10 * iter) {
    fun();
    fun();
  }
  return 10 * iter;
}

void fun

(

)

Definition at line 28 of file BenchmarkTest.cpp.

References folly::doNotOptimizeAway(), and x.

Referenced by BENCHMARK(), BENCHMARK_MULTI(), BENCHMARK_RELATIVE_MULTI(), folly::Function< std::vector< ResultT >(std::vector< InputT > &&)>::Function(), folly::getGlobalBenchmarkBaselineIndex(), folly::lazy(), folly::Function< std::vector< ResultT >(std::vector< InputT > &&)>::operator=(), paramMulti(), paramMultiRel(), folly::runBenchmarkGetNSPerIteration(), and TEST().

           {
  static double x = 1;
  ++x;
  doNotOptimizeAway(x);
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 352 of file BenchmarkTest.cpp.

References folly::runBenchmarks(), and folly::runBenchmarksOnFlag().

                                {
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  runBenchmarks();
  runBenchmarksOnFlag();
}

unsigned paramMulti	(	unsigned	iter,
		unsigned	num
	)

Definition at line 298 of file BenchmarkTest.cpp.

References fun(), and i.

Referenced by paramMultiRel().

                                                 {
  for (unsigned i = 0; i < iter; ++i) {
    for (unsigned j = 0; j < num; ++j) {
      fun();
    }
  }
  return num * iter;
}

unsigned paramMultiRel	(	unsigned	iter,
		unsigned	num
	)

Definition at line 307 of file BenchmarkTest.cpp.

References folly::BENCHMARK_DRAW_LINE(), BENCHMARK_PARAM_MULTI, BENCHMARK_RELATIVE_PARAM_MULTI, fun(), i, and paramMulti().

                                                    {
  for (unsigned i = 0; i < iter; ++i) {
    for (unsigned j = 0; j < num; ++j) {
      fun();
      fun();
    }
  }
  return num * iter;
}