main.cpp File Reference

#include <folly/test/function_benchmark/benchmark_impl.h>
#include <folly/test/function_benchmark/test_functions.h>
#include <glog/logging.h>
#include <folly/Benchmark.h>
#include <folly/ScopeGuard.h>
#include <folly/portability/GFlags.h>

Go to the source code of this file.

Functions
	DECLARE_int32 (bm_max_iters)
	BENCHMARK (fn_invoke, iters)
	BENCHMARK (fn_ptr_invoke, iters)
	BENCHMARK (std_function_invoke, iters)
	BENCHMARK (Function_invoke, iters)
	BENCHMARK (mem_fn_invoke, iters)
	BENCHMARK (fn_ptr_invoke_through_inline, iters)
	BENCHMARK (lambda_invoke_fn, iters)
	BENCHMARK (lambda_noop, iters)
	BENCHMARK (lambda_local_var, iters)
	BENCHMARK (fn_ptr_invoke_through_template, iters)
	BENCHMARK (virtual_fn_invoke, iters)
	BENCHMARK (fn_ptr_create_invoke, iters)
	BENCHMARK (std_function_create_invoke, iters)
	BENCHMARK (Function_create_invoke, iters)
	BENCHMARK (mem_fn_create_invoke, iters)
	BENCHMARK (std_bind_create_invoke, iters)
	BENCHMARK (std_bind_direct_invoke, iters)
	BENCHMARK (scope_guard_std_function, iters)
	BENCHMARK (scope_guard_std_function_rvalue, iters)
	BENCHMARK (scope_guard_Function_rvalue, iters)
	BENCHMARK (scope_guard_fn_ptr, iters)
	BENCHMARK (scope_guard_lambda_noop, iters)
	BENCHMARK (scope_guard_lambda_function, iters)
	BENCHMARK (scope_guard_lambda_local_var, iters)
	BENCHMARK_DRAW_LINE ()
	BENCHMARK (throw_exception, iters)
	BENCHMARK (catch_no_exception, iters)
	BENCHMARK (return_exc_ptr, iters)
	BENCHMARK (exc_ptr_param_return, iters)
	BENCHMARK (exc_ptr_param_return_null, iters)
	BENCHMARK (return_string, iters)
	BENCHMARK (return_string_noexcept, iters)
	BENCHMARK (return_code, iters)
	BENCHMARK (return_code_noexcept, iters)
	BENCHMARK (std_function_create_move_invoke, iters)
	BENCHMARK (Function_create_move_invoke, iters)
	BENCHMARK (std_function_create_move_invoke_small, iters)
	BENCHMARK (Function_create_move_invoke_small, iters)
	BENCHMARK (std_function_create_move_invoke_ref, iters)
	BENCHMARK (Function_create_move_invoke_ref, iters)
	BENCHMARK (function_ptr_move, iters)
	BENCHMARK (std_function_move_small, iters)
	BENCHMARK (Function_move_small, iters)
	BENCHMARK (std_function_move_small_trivial, iters)
	BENCHMARK (Function_move_small_trivial, iters)
	BENCHMARK (std_function_move_large, iters)
	BENCHMARK (Function_move_large, iters)
int	main (int argc, char **argv)

Function Documentation

BENCHMARK	(	fn_invoke	,
		iters
	)

Definition at line 32 of file main.cpp.

References doNothing().

                            {
  for (size_t n = 0; n < iters; ++n) {
    doNothing();
  }
}

BENCHMARK	(	fn_ptr_invoke	,
		iters
	)

Definition at line 39 of file main.cpp.

References BM_fn_ptr_invoke_impl(), and doNothing().

                                {
  BM_fn_ptr_invoke_impl(iters, doNothing);
}

BENCHMARK	(	std_function_invoke	,
		iters
	)

Definition at line 44 of file main.cpp.

References BM_std_function_invoke_impl(), and doNothing().

                                      {
  BM_std_function_invoke_impl(iters, doNothing);
}

BENCHMARK	(	Function_invoke	,
		iters
	)

Definition at line 49 of file main.cpp.

References BM_Function_invoke_impl(), and doNothing().

                                  {
  BM_Function_invoke_impl(iters, doNothing);
}

BENCHMARK	(	mem_fn_invoke	,
		iters
	)

Definition at line 54 of file main.cpp.

References BM_mem_fn_invoke_impl(), TestClass::doNothing(), and tc.

                                {
  TestClass tc;
  BM_mem_fn_invoke_impl(iters, &tc, &TestClass::doNothing);
}

BENCHMARK	(	fn_ptr_invoke_through_inline	,
		iters
	)

Definition at line 60 of file main.cpp.

References BM_fn_ptr_invoke_inlined_impl(), and doNothing().

                                               {
  BM_fn_ptr_invoke_inlined_impl(iters, doNothing);
}

BENCHMARK	(	lambda_invoke_fn	,
		iters
	)

Definition at line 65 of file main.cpp.

References BM_invoke_fn_template_impl(), and doNothing().

                                   {
  BM_invoke_fn_template_impl(iters, [] { doNothing(); });
}

BENCHMARK	(	lambda_noop	,
		iters
	)

Definition at line 70 of file main.cpp.

References BM_invoke_fn_template_impl().

                              {
  BM_invoke_fn_template_impl(iters, [] {});
}

BENCHMARK	(	lambda_local_var	,
		iters
	)

Definition at line 75 of file main.cpp.

References BM_invoke_fn_template_impl(), and uint32_t.

                                   {
  uint32_t count1 = 0;
  uint32_t count2 = 0;
  BM_invoke_fn_template_impl(iters, [&] {
    // Do something slightly more complicated than just incrementing a
    // variable.  Otherwise gcc is smart enough to optimize the loop away.
    if (count1 & 0x1) {
      ++count2;
    }
    ++count1;
  });

  // Use the values we computed, so gcc won't optimize the loop away
  CHECK_EQ(iters, count1);
  CHECK_EQ(iters / 2, count2);
}

BENCHMARK	(	fn_ptr_invoke_through_template	,
		iters
	)

Definition at line 93 of file main.cpp.

References BM_invoke_fn_template_impl(), and doNothing().

                                                 {
  BM_invoke_fn_template_impl(iters, doNothing);
}

BENCHMARK	(	virtual_fn_invoke	,
		iters
	)

Definition at line 98 of file main.cpp.

References BM_virtual_fn_invoke_impl().

                                    {
  VirtualClass vc;
  BM_virtual_fn_invoke_impl(iters, &vc);
}

BENCHMARK	(	fn_ptr_create_invoke	,
		iters
	)

Definition at line 104 of file main.cpp.

References doNothing().

                                       {
  for (size_t n = 0; n < iters; ++n) {
    void (*fn)() = doNothing;
    fn();
  }
}

BENCHMARK	(	std_function_create_invoke	,
		iters
	)

Definition at line 112 of file main.cpp.

References doNothing().

                                             {
  for (size_t n = 0; n < iters; ++n) {
    std::function<void()> fn = doNothing;
    fn();
  }
}

BENCHMARK	(	Function_create_invoke	,
		iters
	)

Definition at line 121 of file main.cpp.

References doNothing().

                                         {
  for (size_t n = 0; n < iters; ++n) {
    folly::Function<void()> fn = doNothing;
    fn();
  }
}

BENCHMARK	(	mem_fn_create_invoke	,
		iters
	)

Definition at line 129 of file main.cpp.

References TestClass::doNothing(), and tc.

                                       {
  TestClass tc;
  for (size_t n = 0; n < iters; ++n) {
    void (TestClass::*memfn)() = &TestClass::doNothing;
    (tc.*memfn)();
  }
}

BENCHMARK	(	std_bind_create_invoke	,
		iters
	)

Definition at line 139 of file main.cpp.

References folly::netops::bind(), TestClass::doNothing(), and tc.

                                         {
  TestClass tc;
  for (size_t n = 0; n < iters; ++n) {
    std::function<void()> fn = std::bind(&TestClass::doNothing, &tc);
    fn();
  }
}

BENCHMARK	(	std_bind_direct_invoke	,
		iters
	)

Definition at line 148 of file main.cpp.

References folly::netops::bind(), TestClass::doNothing(), and tc.

                                         {
  TestClass tc;
  for (size_t n = 0; n < iters; ++n) {
    auto fn = std::bind(&TestClass::doNothing, &tc);
    fn();
  }
}

BENCHMARK	(	scope_guard_std_function	,
		iters
	)

Definition at line 157 of file main.cpp.

References doNothing(), g(), and folly::makeGuard().

                                           {
  std::function<void()> fn(doNothing);
  for (size_t n = 0; n < iters; ++n) {
    auto g = makeGuard(fn);
    (void)g;
  }
}

BENCHMARK	(	scope_guard_std_function_rvalue	,
		iters
	)

Definition at line 167 of file main.cpp.

References doNothing(), g(), and folly::makeGuard().

                                                  {
  for (size_t n = 0; n < iters; ++n) {
    auto g = makeGuard(std::function<void()>(doNothing));
    (void)g;
  }
}

BENCHMARK	(	scope_guard_Function_rvalue	,
		iters
	)

Definition at line 176 of file main.cpp.

References doNothing(), g(), and folly::makeGuard().

                                              {
  for (size_t n = 0; n < iters; ++n) {
    auto g = makeGuard(folly::Function<void()>(doNothing));
    (void)g;
  }
}

BENCHMARK	(	scope_guard_fn_ptr	,
		iters
	)

Definition at line 184 of file main.cpp.

References doNothing(), g(), and folly::makeGuard().

                                     {
  for (size_t n = 0; n < iters; ++n) {
    auto g = makeGuard(doNothing);
    (void)g;
  }
}

BENCHMARK	(	scope_guard_lambda_noop	,
		iters
	)

Definition at line 192 of file main.cpp.

References g(), and folly::makeGuard().

                                          {
  for (size_t n = 0; n < iters; ++n) {
    auto g = makeGuard([] {});
    (void)g;
  }
}

BENCHMARK	(	scope_guard_lambda_function	,
		iters
	)

Definition at line 200 of file main.cpp.

References doNothing(), g(), and folly::makeGuard().

                                              {
  for (size_t n = 0; n < iters; ++n) {
    auto g = makeGuard([] { doNothing(); });
    (void)g;
  }
}

BENCHMARK	(	scope_guard_lambda_local_var	,
		iters
	)

Definition at line 208 of file main.cpp.

References BENCHMARK_DRAW_LINE(), count, g(), folly::makeGuard(), and uint32_t.

                                               {
  uint32_t count = 0;
  for (size_t n = 0; n < iters; ++n) {
    auto g = makeGuard([&] {
      // Increment count if n is odd.  Without this conditional check
      // (i.e., if we just increment count each time through the loop),
      // gcc is smart enough to optimize the entire loop away, and just set
      // count = iters.
      if (n & 0x1) {
        ++count;
      }
    });
    (void)g;
  }

  // Check that the value of count is what we expect.
  // This check is necessary: if we don't use count, gcc detects that count is
  // unused and optimizes the entire loop away.
  CHECK_EQ(iters / 2, count);
}

BENCHMARK	(	throw_exception	,
		iters
	)

Definition at line 231 of file main.cpp.

                                  {
  for (size_t n = 0; n < iters; ++n) {
    try {
      folly::throw_exception<Exception>("this is a test");
    } catch (const std::exception& ex) {
    }
  }
}

BENCHMARK	(	catch_no_exception	,
		iters
	)

Definition at line 240 of file main.cpp.

References doNothing().

                                     {
  for (size_t n = 0; n < iters; ++n) {
    try {
      doNothing();
    } catch (const std::exception& ex) {
    }
  }
}

BENCHMARK	(	return_exc_ptr	,
		iters
	)

Definition at line 249 of file main.cpp.

References returnExceptionPtr().

                                 {
  for (size_t n = 0; n < iters; ++n) {
    returnExceptionPtr();
  }
}

BENCHMARK	(	exc_ptr_param_return	,
		iters
	)

Definition at line 255 of file main.cpp.

References exceptionPtrReturnParam().

                                       {
  for (size_t n = 0; n < iters; ++n) {
    std::exception_ptr ex;
    exceptionPtrReturnParam(&ex);
  }
}

BENCHMARK	(	exc_ptr_param_return_null	,
		iters
	)

Definition at line 262 of file main.cpp.

References exceptionPtrReturnParam().

                                            {
  for (size_t n = 0; n < iters; ++n) {
    exceptionPtrReturnParam(nullptr);
  }
}

BENCHMARK	(	return_string	,
		iters
	)

Definition at line 268 of file main.cpp.

References returnString().

                                {
  for (size_t n = 0; n < iters; ++n) {
    returnString();
  }
}

BENCHMARK	(	return_string_noexcept	,
		iters
	)

Definition at line 274 of file main.cpp.

References returnStringNoExcept().

                                         {
  for (size_t n = 0; n < iters; ++n) {
    returnStringNoExcept();
  }
}

BENCHMARK	(	return_code	,
		iters
	)

Definition at line 280 of file main.cpp.

References returnCode().

                              {
  for (size_t n = 0; n < iters; ++n) {
    returnCode(false);
  }
}

BENCHMARK	(	return_code_noexcept	,
		iters
	)

Definition at line 286 of file main.cpp.

References BENCHMARK_DRAW_LINE(), and returnCodeNoExcept().

                                       {
  for (size_t n = 0; n < iters; ++n) {
    returnCodeNoExcept(false);
  }
}

BENCHMARK	(	std_function_create_move_invoke	,
		iters
	)

Definition at line 294 of file main.cpp.

References a, f, i, folly::pushmi::invoke, and folly::gen::move.

                                                  {
  LargeClass a;
  for (size_t i = 0; i < iters; ++i) {
    std::function<void()> f(a);
    invoke(std::move(f));
  }
}

BENCHMARK	(	Function_create_move_invoke	,
		iters
	)

Definition at line 302 of file main.cpp.

References a, f, i, folly::pushmi::invoke, and folly::gen::move.

                                              {
  LargeClass a;
  for (size_t i = 0; i < iters; ++i) {
    folly::Function<void()> f(a);
    invoke(std::move(f));
  }
}

BENCHMARK	(	std_function_create_move_invoke_small	,
		iters
	)

Definition at line 310 of file main.cpp.

References doNothing(), f, i, folly::pushmi::invoke, and folly::gen::move.

                                                        {
  for (size_t i = 0; i < iters; ++i) {
    std::function<void()> f(doNothing);
    invoke(std::move(f));
  }
}

BENCHMARK	(	Function_create_move_invoke_small	,
		iters
	)

Definition at line 317 of file main.cpp.

References doNothing(), f, i, folly::pushmi::invoke, and folly::gen::move.

                                                    {
  for (size_t i = 0; i < iters; ++i) {
    folly::Function<void()> f(doNothing);
    invoke(std::move(f));
  }
}

BENCHMARK	(	std_function_create_move_invoke_ref	,
		iters
	)

Definition at line 324 of file main.cpp.

References a, f, i, folly::pushmi::invoke, and folly::gen::move.

                                                      {
  LargeClass a;
  for (size_t i = 0; i < iters; ++i) {
    std::function<void()> f(std::ref(a));
    invoke(std::move(f));
  }
}

BENCHMARK	(	Function_create_move_invoke_ref	,
		iters
	)

Definition at line 332 of file main.cpp.

References a, BENCHMARK_DRAW_LINE(), f, i, folly::pushmi::invoke, and folly::gen::move.

                                                  {
  LargeClass a;
  for (size_t i = 0; i < iters; ++i) {
    folly::Function<void()> f(std::ref(a));
    invoke(std::move(f));
  }
}

BENCHMARK	(	function_ptr_move	,
		iters
	)

Definition at line 342 of file main.cpp.

References doNothing(), folly::doNotOptimizeAway(), f, i, and folly::gen::move.

                                    {
  auto f = &doNothing;
  for (size_t i = 0; i < iters; ++i) {
    auto f2 = std::move(f);
    folly::doNotOptimizeAway(f2);
    f = std::move(f2);
  }
}

BENCHMARK	(	std_function_move_small	,
		iters
	)

Definition at line 351 of file main.cpp.

References a, doNothing(), folly::doNotOptimizeAway(), f, i, and folly::gen::move.

                                          {
  std::shared_ptr<int> a(new int);
  std::function<void()> f([a]() { doNothing(); });
  for (size_t i = 0; i < iters; ++i) {
    auto f2 = std::move(f);
    folly::doNotOptimizeAway(f2);
    f = std::move(f2);
  }
}

BENCHMARK	(	Function_move_small	,
		iters
	)

Definition at line 361 of file main.cpp.

References a, doNothing(), folly::doNotOptimizeAway(), f, i, and folly::gen::move.

                                      {
  std::shared_ptr<int> a(new int);
  folly::Function<void()> f([a]() { doNothing(); });
  for (size_t i = 0; i < iters; ++i) {
    auto f2 = std::move(f);
    folly::doNotOptimizeAway(f2);
    f = std::move(f2);
  }
}

BENCHMARK	(	std_function_move_small_trivial	,
		iters
	)

Definition at line 371 of file main.cpp.

References doNothing(), folly::doNotOptimizeAway(), f, i, and folly::gen::move.

                                                  {
  std::function<void()> f(doNothing);
  for (size_t i = 0; i < iters; ++i) {
    auto f2 = std::move(f);
    folly::doNotOptimizeAway(f2);
    f = std::move(f2);
  }
}

BENCHMARK	(	Function_move_small_trivial	,
		iters
	)

Definition at line 380 of file main.cpp.

References doNothing(), folly::doNotOptimizeAway(), f, i, and folly::gen::move.

                                              {
  folly::Function<void()> f(doNothing);
  for (size_t i = 0; i < iters; ++i) {
    auto f2 = std::move(f);
    folly::doNotOptimizeAway(f2);
    f = std::move(f2);
  }
}

BENCHMARK	(	std_function_move_large	,
		iters
	)

Definition at line 389 of file main.cpp.

References a, folly::doNotOptimizeAway(), f, i, and folly::gen::move.

                                          {
  LargeClass a;
  std::function<void()> f(a);
  for (size_t i = 0; i < iters; ++i) {
    auto f2 = std::move(f);
    folly::doNotOptimizeAway(f2);
    f = std::move(f2);
  }
}

BENCHMARK	(	Function_move_large	,
		iters
	)

Definition at line 399 of file main.cpp.

References a, folly::doNotOptimizeAway(), f, i, and folly::gen::move.

                                      {
  LargeClass a;
  folly::Function<void()> f(a);
  for (size_t i = 0; i < iters; ++i) {
    auto f2 = std::move(f);
    folly::doNotOptimizeAway(f2);
    f = std::move(f2);
  }
}

BENCHMARK_DRAW_LINE

(

)

Referenced by BENCHMARK().

DECLARE_int32

(

bm_max_iters

)

int main	(	int	argc,
		char **	argv
	)

Definition at line 411 of file main.cpp.

References folly::runBenchmarks().

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