CallOnceTest.cpp File Reference

#include <deque>
#include <mutex>
#include <thread>
#include <folly/portability/GTest.h>
#include <folly/synchronization/CallOnce.h>

Go to the source code of this file.

Functions
template<typename CallOnceFunc >
void	bm_impl (CallOnceFunc &&fn, size_t iters)
	TEST (FollyCallOnce, Simple)
	TEST (FollyCallOnce, Exception)
	TEST (FollyCallOnce, Stress)

Variables
static size_t const	kNumThreads = 16

Function Documentation

template<typename CallOnceFunc >

void bm_impl	(	CallOnceFunc &&	fn,
		size_t	iters
	)

Definition at line 27 of file CallOnceTest.cpp.

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

Referenced by TEST().

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

TEST	(	FollyCallOnce	,
		Simple
	)

Definition at line 41 of file CallOnceTest.cpp.

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

                            {
  folly::once_flag flag;
  auto fn = [&](int* outp) { ++*outp; };
  int out = 0;
  folly::call_once(flag, fn, &out);
  folly::call_once(flag, fn, &out);
  ASSERT_EQ(1, out);
}

TEST	(	FollyCallOnce	,
		Exception
	)

Definition at line 50 of file CallOnceTest.cpp.

References folly::call_once(), EXPECT_EQ, EXPECT_THROW, and flag.

                               {
  struct ExpectedException {};
  folly::once_flag flag;
  size_t numCalls = 0;
  EXPECT_THROW(
      folly::call_once(
          flag,
          [&] {
            ++numCalls;
            throw ExpectedException();
          }),
      ExpectedException);
  EXPECT_EQ(1, numCalls);
  folly::call_once(flag, [&] { ++numCalls; });
  EXPECT_EQ(2, numCalls);
}

TEST	(	FollyCallOnce	,
		Stress
	)

Definition at line 67 of file CallOnceTest.cpp.

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

                            {
  for (int i = 0; i < 100; ++i) {
    folly::once_flag flag;
    int out = 0;
    bm_impl([&] { folly::call_once(flag, [&] { ++out; }); }, 100);
    ASSERT_EQ(1, out);
  }
}

Variable Documentation

size_t const kNumThreads = 16

static

Definition at line 24 of file CallOnceTest.cpp.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), bm_impl(), TEST(), and TEST_F().