BaseBenchmark.cpp File Reference

#include <atomic>
#include <glog/logging.h>
#include <folly/Benchmark.h>
#include <folly/gen/Base.h>

Go to the source code of this file.

Classes
struct	FibYielder

Functions
static std::atomic< int >	testSize (1000)
	BENCHMARK (Sum_Basic_NoGen, iters)
	BENCHMARK_RELATIVE (Sum_Basic_Gen, iters)
	BENCHMARK_DRAW_LINE ()
	BENCHMARK (Sum_Vector_NoGen, iters)
	BENCHMARK_RELATIVE (Sum_Vector_Gen, iters)
	BENCHMARK (Member, iters)
	BENCHMARK_RELATIVE (MapMember, iters)
	BENCHMARK (Count_Vector_NoGen, iters)
	BENCHMARK_RELATIVE (Count_Vector_Gen, iters)
	BENCHMARK (Fib_Sum_NoGen, iters)
	BENCHMARK_RELATIVE (Fib_Sum_Gen, iters)
	BENCHMARK_RELATIVE (Fib_Sum_Gen_Limit, iters)
	BENCHMARK_RELATIVE (Fib_Sum_Gen_Static, iters)
	BENCHMARK (VirtualGen_0Virtual, iters)
	BENCHMARK_RELATIVE (VirtualGen_1Virtual, iters)
	BENCHMARK_RELATIVE (VirtualGen_2Virtual, iters)
	BENCHMARK_RELATIVE (VirtualGen_3Virtual, iters)
	BENCHMARK (Concat_NoGen, iters)
	BENCHMARK_RELATIVE (Concat_Gen, iters)
	BENCHMARK (Composed_NoGen, iters)
	BENCHMARK_RELATIVE (Composed_Gen, iters)
	BENCHMARK_RELATIVE (Composed_GenRegular, iters)
	BENCHMARK (Sample, iters)
int	main (int argc, char *argv[])

Variables
static vector< int >	testVector
static vector< vector< int > >	testVectorVector
static vector< fbstring >	strings
auto	square = [](int x) { return x * x; }

Function Documentation

BENCHMARK	(	Sum_Basic_NoGen	,
		iters
	)

Definition at line 52 of file BaseBenchmark.cpp.

References folly::doNotOptimizeAway(), i, s, and testSize().

                                  {
  int limit = testSize.load();
  int s = 0;
  while (iters--) {
    for (int i = 0; i < limit; ++i) {
      s += i;
    }
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK	(	Sum_Vector_NoGen	,
		iters
	)

Definition at line 74 of file BaseBenchmark.cpp.

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

                                   {
  int s = 0;
  while (iters--) {
    for (auto& i : testVector) {
      s += i;
    }
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK	(	Member	,
		iters
	)

Definition at line 94 of file BaseBenchmark.cpp.

References folly::doNotOptimizeAway(), folly::gen::from(), folly::gen::member(), s, folly::basic_fbstring< char >::size(), and folly::gen::sum.

                         {
  int s = 0;
  while (iters--) {
    // clang-format off
    s += from(strings)
       | member(&fbstring::size)
       | sum;
    // clang-format on
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK	(	Count_Vector_NoGen	,
		iters
	)

Definition at line 120 of file BaseBenchmark.cpp.

References folly::doNotOptimizeAway(), and s.

                                     {
  int s = 0;
  while (iters--) {
    for (auto& i : testVector) {
      if (i * 2 < rand()) {
        ++s;
      }
    }
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK	(	Fib_Sum_NoGen	,
		iters
	)

Definition at line 148 of file BaseBenchmark.cpp.

References a, b, folly::doNotOptimizeAway(), fib(), s, testSize(), and v.

                                {
  int s = 0;
  while (iters--) {
    auto fib = [](size_t limit) -> vector<int> {
      vector<int> ret;
      int a = 0;
      int b = 1;
      for (size_t i = 0; i < limit; i += 2) {
        ret.push_back(a += b);
        ret.push_back(b += a);
      }
      return ret;
    };
    for (auto& v : fib(testSize.load())) {
      s += v;
    }
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK	(	VirtualGen_0Virtual	,
		iters
	)

Definition at line 226 of file BaseBenchmark.cpp.

References folly::doNotOptimizeAway(), folly::gen::map(), s, folly::gen::seq(), square, and folly::gen::sum.

                                      {
  int s = 0;
  while (iters--) {
    auto numbers = seq(1, 10000);
    auto squares = numbers | map(square);
    auto quads = squares | map(square);
    s += quads | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK	(	Concat_NoGen	,
		iters
	)

Definition at line 272 of file BaseBenchmark.cpp.

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

                               {
  int s = 0;
  while (iters--) {
    for (auto& v : testVectorVector) {
      for (auto& i : v) {
        s += i;
      }
    }
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK	(	Composed_NoGen	,
		iters
	)

Definition at line 294 of file BaseBenchmark.cpp.

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

                                 {
  int s = 0;
  while (iters--) {
    for (auto& i : testVector) {
      s += i * i;
    }
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK	(	Sample	,
		iters
	)

Definition at line 323 of file BaseBenchmark.cpp.

References folly::doNotOptimizeAway(), s, folly::gen::sample(), folly::gen::seq(), and folly::gen::sum.

                         {
  size_t s = 0;
  while (iters--) {
    auto sampler = seq(1, 10 * 1000 * 1000) | sample(1000);
    s += (sampler | sum);
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_DRAW_LINE

(

)

BENCHMARK_RELATIVE	(	Sum_Basic_Gen	,
		iters
	)

Definition at line 63 of file BaseBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), folly::gen::range(), s, folly::gen::sum, and testSize().

                                         {
  int limit = testSize.load();
  int s = 0;
  while (iters--) {
    s += range(0, limit) | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	Sum_Vector_Gen	,
		iters
	)

Definition at line 84 of file BaseBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), folly::gen::from(), s, and folly::gen::sum.

                                          {
  int s = 0;
  while (iters--) {
    s += from(testVector) | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	MapMember	,
		iters
	)

Definition at line 106 of file BaseBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), folly::gen::from(), folly::gen::map(), s, and folly::gen::sum.

                                     {
  int s = 0;
  while (iters--) {
    // clang-format off
    s += from(strings)
       | map([](const fbstring& x) { return x.size(); })
       | sum;
    // clang-format on
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	Count_Vector_Gen	,
		iters
	)

Definition at line 132 of file BaseBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::gen::count, folly::doNotOptimizeAway(), folly::gen::filter(), folly::gen::from(), and s.

                                            {
  int s = 0;
  while (iters--) {
    // clang-format off
    s += from(testVector)
       | filter([](int i) {
                  return i * 2 < rand();
                })
       | count;
    // clang-format on
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	Fib_Sum_Gen	,
		iters
	)

Definition at line 168 of file BaseBenchmark.cpp.

References a, b, folly::doNotOptimizeAway(), fib(), GENERATOR, s, folly::gen::sum, folly::gen::take(), testSize(), and folly::fibers::yield().

                                       {
  int s = 0;
  while (iters--) {
    auto fib = GENERATOR(int) {
      int a = 0;
      int b = 1;
      for (;;) {
        yield(a += b);
        yield(b += a);
      }
    };
    // Early stopping implemented with exceptions.
    s += fib | take(testSize.load()) | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	Fib_Sum_Gen_Limit	,
		iters
	)

Definition at line 185 of file BaseBenchmark.cpp.

References a, b, folly::doNotOptimizeAway(), fib(), GENERATOR, s, folly::gen::sum, testSize(), and folly::fibers::yield().

                                             {
  int s = 0;
  while (iters--) {
    size_t limit = testSize.load();
    auto fib = GENERATOR(int) {
      int a = 0;
      int b = 1;
      for (size_t i = 0; i < limit; i += 2) {
        yield(a += b);
        yield(b += a);
      }
    };
    // No early stopping.
    s += fib | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	Fib_Sum_Gen_Static	,
		iters
	)

Definition at line 215 of file BaseBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), fib(), s, folly::gen::sum, folly::gen::take(), and testSize().

                                              {
  int s = 0;
  while (iters--) {
    auto fib = generator<int>(FibYielder());
    s += fib | take(testSize.load()) | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	VirtualGen_1Virtual	,
		iters
	)

Definition at line 237 of file BaseBenchmark.cpp.

References folly::doNotOptimizeAway(), folly::gen::map(), s, folly::gen::seq(), square, and folly::gen::sum.

                                               {
  int s = 0;
  while (iters--) {
    VirtualGen<int> numbers = seq(1, 10000);
    auto squares = numbers | map(square);
    auto quads = squares | map(square);
    s += quads | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	VirtualGen_2Virtual	,
		iters
	)

Definition at line 248 of file BaseBenchmark.cpp.

References folly::doNotOptimizeAway(), folly::gen::map(), s, folly::gen::seq(), square, and folly::gen::sum.

                                               {
  int s = 0;
  while (iters--) {
    VirtualGen<int> numbers = seq(1, 10000);
    VirtualGen<int> squares = numbers | map(square);
    auto quads = squares | map(square);
    s += quads | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	VirtualGen_3Virtual	,
		iters
	)

Definition at line 259 of file BaseBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), folly::gen::map(), s, folly::gen::seq(), square, and folly::gen::sum.

                                               {
  int s = 0;
  while (iters--) {
    VirtualGen<int> numbers = seq(1, 10000);
    VirtualGen<int> squares = numbers | map(square);
    VirtualGen<int> quads = squares | map(square);
    s += quads | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	Concat_Gen	,
		iters
	)

Definition at line 284 of file BaseBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), folly::gen::from(), folly::gen::rconcat, s, and folly::gen::sum.

                                      {
  int s = 0;
  while (iters--) {
    s += from(testVectorVector) | rconcat | sum;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	Composed_Gen	,
		iters
	)

Definition at line 304 of file BaseBenchmark.cpp.

References folly::doNotOptimizeAway(), folly::gen::from(), folly::gen::map(), s, square, and folly::gen::sum.

                                        {
  int s = 0;
  auto sumSq = map(square) | sum;
  while (iters--) {
    s += from(testVector) | sumSq;
  }
  folly::doNotOptimizeAway(s);
}

BENCHMARK_RELATIVE	(	Composed_GenRegular	,
		iters
	)

Definition at line 313 of file BaseBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), folly::gen::from(), folly::gen::map(), s, square, and folly::gen::sum.

                                               {
  int s = 0;
  while (iters--) {
    s += from(testVector) | map(square) | sum;
  }
  folly::doNotOptimizeAway(s);
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 367 of file BaseBenchmark.cpp.

References folly::runBenchmarks().

                                 {
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  folly::runBenchmarks();
  return 0;
}

static std::atomic<int> testSize ( 1000  )

static

Referenced by BENCHMARK(), and BENCHMARK_RELATIVE().

Variable Documentation

auto square = [](int x) { return x * x; }

Definition at line 50 of file BaseBenchmark.cpp.

Referenced by BENCHMARK(), and BENCHMARK_RELATIVE().

vector<fbstring> strings

static

Initial value:

=
    from(testVector)
  | eachTo<fbstring>()
  | as<vector>()

Definition at line 44 of file BaseBenchmark.cpp.

Referenced by testing::gtest_printers_test::AllowsGenericStreamingAndImplicitConversionTemplate< T >::operator bool(), testing::internal::UniversalTersePrinter< wchar_t * >::Print(), TEST(), testing::gtest_printers_test::TEST(), and testString2Integral().

vector<int> testVector

static

Initial value:

=
    seq(1, testSize.load())
  | mapped([](int) { return rand(); })
  | as<vector>()

Definition at line 33 of file BaseBenchmark.cpp.

vector<vector<int> > testVectorVector

static

Initial value:

=
    seq(1, 100)
  | map([](int i) {
      return seq(1, i) | as<vector>();
    })
  | as<vector>()

Definition at line 38 of file BaseBenchmark.cpp.