SaturatingSemaphoreTest.cpp File Reference

#include <folly/synchronization/SaturatingSemaphore.h>
#include <folly/portability/GTest.h>
#include <folly/test/DeterministicSchedule.h>

Go to the source code of this file.

Typedefs
using	DSched = folly::test::DeterministicSchedule

Functions
template<bool MayBlock, template< typename > class Atom = std::atomic>
void	run_basic_test ()
template<bool MayBlock, template< typename > class Atom = std::atomic>
void	run_pingpong_test (int numRounds)
template<bool MayBlock, template< typename > class Atom = std::atomic>
void	run_multi_poster_multi_waiter_test (int np, int nw)
	TEST (SaturatingSemaphore, basic_spin_only)
	Tests. More...
	TEST (SaturatingSemaphore, basic_may_block)
	TEST (SaturatingSemaphore, pingpong_spin_only)
	TEST (SaturatingSemaphore, pingpong_may_block)
	TEST (SaturatingSemaphore, multi_poster_multi_waiter_spin_only)
	TEST (SaturatingSemaphore, multi_poster_multi_waiter_may_block)

Typedef Documentation

using DSched = folly::test::DeterministicSchedule

Definition at line 24 of file SaturatingSemaphoreTest.cpp.

Function Documentation

template<bool MayBlock, template< typename > class Atom = std::atomic>

void run_basic_test

(

)

Definition at line 27 of file SaturatingSemaphoreTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, Atom, f, now(), folly::SaturatingSemaphore< MayBlock, Atom >::post(), folly::SaturatingSemaphore< MayBlock, Atom >::ready(), folly::SaturatingSemaphore< MayBlock, Atom >::reset(), folly::SaturatingSemaphore< MayBlock, Atom >::try_wait(), folly::SaturatingSemaphore< MayBlock, Atom >::try_wait_until(), folly::SaturatingSemaphore< MayBlock, Atom >::wait(), and folly::SaturatingSemaphore< MayBlock, Atom >::wait_options().

                      {
  SaturatingSemaphore<MayBlock, Atom> f;
  ASSERT_FALSE(f.ready());
  ASSERT_FALSE(f.try_wait());
  ASSERT_FALSE(f.try_wait_until(
      std::chrono::steady_clock::now() + std::chrono::microseconds(1)));
  ASSERT_FALSE(f.try_wait_until(
      std::chrono::steady_clock::now() + std::chrono::microseconds(1),
      f.wait_options().spin_max(std::chrono::microseconds(1))));
  f.post();
  f.post();
  f.wait();
  f.wait(f.wait_options().spin_max(std::chrono::nanoseconds(100)));
  ASSERT_TRUE(f.ready());
  ASSERT_TRUE(f.try_wait());
  ASSERT_TRUE(f.try_wait_until(
      std::chrono::steady_clock::now() + std::chrono::microseconds(1)));
  f.wait();
  f.reset();
  ASSERT_FALSE(f.try_wait());
}

template<bool MayBlock, template< typename > class Atom = std::atomic>

void run_multi_poster_multi_waiter_test	(	int	np,
		int	nw
	)

Definition at line 73 of file SaturatingSemaphoreTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, f, i, folly::test::DeterministicSchedule::join(), now(), folly::SaturatingSemaphore< MayBlock, Atom >::post(), folly::SaturatingSemaphore< MayBlock, Atom >::ready(), folly::pushmi::detail::t, folly::test::DeterministicSchedule::thread(), folly::SaturatingSemaphore< MayBlock, Atom >::try_wait(), folly::SaturatingSemaphore< MayBlock, Atom >::try_wait_for(), folly::SaturatingSemaphore< MayBlock, Atom >::try_wait_until(), folly::SaturatingSemaphore< MayBlock, Atom >::wait(), and folly::SaturatingSemaphore< MayBlock, Atom >::wait_options().

                                                        {
  SaturatingSemaphore<MayBlock, Atom> f;
  std::atomic<int> posted{0};
  std::atomic<int> waited{0};
  std::atomic<bool> go_post{false};
  std::atomic<bool> go_wait{false};

  std::vector<std::thread> prod(np);
  std::vector<std::thread> cons(nw);
  for (int i = 0; i < np; ++i) {
    prod[i] = DSched::thread([&] {
      while (!go_post.load()) {
        /* spin */;
      }
      f.post();
      posted.fetch_add(1);
    });
  }

  for (int i = 0; i < nw; ++i) {
    cons[i] = DSched::thread([&] {
      ASSERT_FALSE(f.ready());
      ASSERT_FALSE(f.try_wait());
      ASSERT_FALSE(f.try_wait_for(std::chrono::microseconds(1)));
      ASSERT_FALSE(f.try_wait_until(
          std::chrono::steady_clock::now() + std::chrono::microseconds(1)));
      ASSERT_FALSE(f.try_wait_until(
          std::chrono::steady_clock::now() + std::chrono::microseconds(1),
          f.wait_options().spin_max(std::chrono::microseconds(0))));
      waited.fetch_add(1);
      while (!go_wait.load()) {
        /* spin */;
      }
      ASSERT_TRUE(f.ready());
      ASSERT_TRUE(f.try_wait());
      ASSERT_TRUE(f.try_wait_for(std::chrono::microseconds(1)));
      ASSERT_TRUE(f.try_wait_until(
          std::chrono::steady_clock::now() + std::chrono::microseconds(1)));
      ASSERT_TRUE(f.try_wait_until(
          std::chrono::steady_clock::now() + std::chrono::microseconds(1),
          f.wait_options().spin_max(std::chrono::microseconds(0))));
      f.wait();
    });
  }

  while (waited.load() < nw) {
    /* spin */;
  }
  go_post.store(true);
  while (posted.load() < np) {
    /* spin */;
  }
  go_wait.store(true);

  for (auto& t : prod) {
    DSched::join(t);
  }
  for (auto& t : cons) {
    DSched::join(t);
  }
}

template<bool MayBlock, template< typename > class Atom = std::atomic>

void run_pingpong_test

(

int

numRounds

)

Definition at line 50 of file SaturatingSemaphoreTest.cpp.

References a, Atom, b, i, folly::test::DeterministicSchedule::join(), and folly::test::DeterministicSchedule::thread().

                                      {
  using WF = SaturatingSemaphore<MayBlock, Atom>;
  std::array<WF, 17> flags;
  WF& a = flags[0];
  WF& b = flags[16]; // different cache line
  auto thr = DSched::thread([&] {
    for (int i = 0; i < numRounds; ++i) {
      a.try_wait();
      a.wait();
      a.reset();
      b.post();
    }
  });
  for (int i = 0; i < numRounds; ++i) {
    a.post();
    b.try_wait();
    b.wait();
    b.reset();
  }
  DSched::join(thr);
}

TEST	(	SaturatingSemaphore	,
		basic_spin_only
	)

Tests.

Definition at line 137 of file SaturatingSemaphoreTest.cpp.

                                           {
  run_basic_test<false>();
}

TEST	(	SaturatingSemaphore	,
		basic_may_block
	)

Definition at line 141 of file SaturatingSemaphoreTest.cpp.

                                           {
  run_basic_test<true>();
}

TEST	(	SaturatingSemaphore	,
		pingpong_spin_only
	)

Definition at line 145 of file SaturatingSemaphoreTest.cpp.

                                              {
  run_pingpong_test<false>(1000);
}

TEST	(	SaturatingSemaphore	,
		pingpong_may_block
	)

Definition at line 149 of file SaturatingSemaphoreTest.cpp.

                                              {
  run_pingpong_test<true>(1000);
}

TEST	(	SaturatingSemaphore	,
		multi_poster_multi_waiter_spin_only
	)

Definition at line 153 of file SaturatingSemaphoreTest.cpp.

                                                               {
  run_multi_poster_multi_waiter_test<false>(1, 1);
  run_multi_poster_multi_waiter_test<false>(1, 10);
  run_multi_poster_multi_waiter_test<false>(10, 1);
  run_multi_poster_multi_waiter_test<false>(10, 10);
}

TEST	(	SaturatingSemaphore	,
		multi_poster_multi_waiter_may_block
	)

Definition at line 160 of file SaturatingSemaphoreTest.cpp.

                                                               {
  run_multi_poster_multi_waiter_test<true>(1, 1);
  run_multi_poster_multi_waiter_test<true>(1, 10);
  run_multi_poster_multi_waiter_test<true>(10, 1);
  run_multi_poster_multi_waiter_test<true>(10, 10);
}