CallOnceBenchmark.cpp File Reference

#include <folly/synchronization/CallOnce.h>
#include <deque>
#include <mutex>
#include <thread>
#include <folly/Benchmark.h>
#include <glog/logging.h>

Go to the source code of this file.

Functions
	DEFINE_int32 (threads, 16,"benchmark concurrency")
template<typename CallOnceFunc >
void	bm_impl (CallOnceFunc &&fn, size_t iters)
	BENCHMARK (StdCallOnceBench, iters)
	BENCHMARK (FollyCallOnceBench, iters)
int	main (int argc, char **argv)

Function Documentation

BENCHMARK	(	StdCallOnceBench	,
		iters
	)

Definition at line 44 of file CallOnceBenchmark.cpp.

References bm_impl(), folly::call_once(), and flag.

                                   {
  std::once_flag flag;
  int out = 0;
  bm_impl([&] { std::call_once(flag, [&] { ++out; }); }, iters);
  CHECK_EQ(1, out);
}

BENCHMARK	(	FollyCallOnceBench	,
		iters
	)

Definition at line 51 of file CallOnceBenchmark.cpp.

References bm_impl(), folly::call_once(), and flag.

                                     {
  folly::once_flag flag;
  int out = 0;
  bm_impl([&] { folly::call_once(flag, [&] { ++out; }); }, iters);
  CHECK_EQ(1, out);
}

template<typename CallOnceFunc >

void bm_impl	(	CallOnceFunc &&	fn,
		size_t	iters
	)

Definition at line 30 of file CallOnceBenchmark.cpp.

References i, folly::pushmi::detail::t, and threads.

Referenced by BENCHMARK().

                                              {
  std::deque<std::thread> threads;
  for (size_t i = 0u; i < size_t(FLAGS_threads); ++i) {
    threads.emplace_back([&fn, iters] {
      for (size_t j = 0u; j < iters; ++j) {
        fn();
      }
    });
  }
  for (std::thread& t : threads) {
    t.join();
  }
}

DEFINE_int32	(	threads	,
		16	,
		"benchmark concurrency"
	)

int main	(	int	argc,
		char **	argv
	)

Definition at line 68 of file CallOnceBenchmark.cpp.

References folly::runBenchmarks().

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