LifoSemTests.cpp File Reference

#include <folly/synchronization/LifoSem.h>
#include <thread>
#include <folly/Benchmark.h>
#include <folly/Random.h>
#include <folly/portability/Asm.h>
#include <folly/portability/GFlags.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Semaphore.h>
#include <folly/test/DeterministicSchedule.h>

Go to the source code of this file.

Classes
class	LifoSemTest

Typedefs
typedef LifoSemImpl< DeterministicAtomic >	DLifoSem
typedef DeterministicSchedule	DSched

Functions
	TEST (LifoSem, basic)
	TEST (LifoSem, multi)
	TEST_F (LifoSemTest, pingpong)
	TEST_F (LifoSemTest, mutex)
	TEST_F (LifoSemTest, no_blocking)
	TEST_F (LifoSemTest, one_way)
	TEST_F (LifoSemTest, shutdown_wait_order)
	TEST_F (LifoSemTest, shutdown_multi)
	TEST (LifoSem, multi_try_wait_simple)
	TEST_F (LifoSemTest, multi_try_wait)
	TEST_F (LifoSemTest, timeout)
	BENCHMARK (lifo_sem_pingpong, iters)
	BENCHMARK (lifo_sem_oneway, iters)
	BENCHMARK (single_thread_lifo_post, iters)
	BENCHMARK (single_thread_lifo_wait, iters)
	BENCHMARK (single_thread_lifo_postwait, iters)
	BENCHMARK (single_thread_lifo_trywait, iters)
	BENCHMARK (single_thread_posix_postwait, iters)
	BENCHMARK (single_thread_posix_trywait, iters)
static void	contendedUse (uint32_t n, int posters, int waiters)
	BENCHMARK_DRAW_LINE ()
int	main (int argc, char **argv)

Typedef Documentation

typedef LifoSemImpl<DeterministicAtomic> DLifoSem

Definition at line 32 of file LifoSemTests.cpp.

typedef DeterministicSchedule DSched

Definition at line 33 of file LifoSemTests.cpp.

Function Documentation

BENCHMARK	(	lifo_sem_pingpong	,
		iters
	)

Definition at line 313 of file LifoSemTests.cpp.

References a, b, i, folly::detail::LifoSemBase< Handoff, Atom >::post(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                                    {
  LifoSem a;
  LifoSem b;
  auto thr = std::thread([&] {
    for (size_t i = 0; i < iters; ++i) {
      a.wait();
      b.post();
    }
  });
  for (size_t i = 0; i < iters; ++i) {
    a.post();
    b.wait();
  }
  thr.join();
}

BENCHMARK	(	lifo_sem_oneway	,
		iters
	)

Definition at line 329 of file LifoSemTests.cpp.

References a, i, folly::detail::LifoSemBase< Handoff, Atom >::post(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                                  {
  LifoSem a;
  auto thr = std::thread([&] {
    for (size_t i = 0; i < iters; ++i) {
      a.wait();
    }
  });
  for (size_t i = 0; i < iters; ++i) {
    a.post();
  }
  thr.join();
}

BENCHMARK	(	single_thread_lifo_post	,
		iters
	)

Definition at line 342 of file LifoSemTests.cpp.

References folly::asm_volatile_memory(), and folly::detail::LifoSemBase< Handoff, Atom >::post().

                                          {
  LifoSem sem;
  for (size_t n = 0; n < iters; ++n) {
    sem.post();
    asm_volatile_memory();
  }
}

BENCHMARK	(	single_thread_lifo_wait	,
		iters
	)

Definition at line 350 of file LifoSemTests.cpp.

References folly::asm_volatile_memory(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                                          {
  LifoSem sem(iters);
  for (size_t n = 0; n < iters; ++n) {
    sem.wait();
    asm_volatile_memory();
  }
}

BENCHMARK	(	single_thread_lifo_postwait	,
		iters
	)

Definition at line 358 of file LifoSemTests.cpp.

References folly::asm_volatile_memory(), folly::detail::LifoSemBase< Handoff, Atom >::post(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                                              {
  LifoSem sem;
  for (size_t n = 0; n < iters; ++n) {
    sem.post();
    asm_volatile_memory();
    sem.wait();
    asm_volatile_memory();
  }
}

BENCHMARK	(	single_thread_lifo_trywait	,
		iters
	)

Definition at line 368 of file LifoSemTests.cpp.

References folly::asm_volatile_memory(), EXPECT_FALSE, and folly::detail::LifoSemBase< Handoff, Atom >::tryWait().

                                             {
  LifoSem sem;
  for (size_t n = 0; n < iters; ++n) {
    EXPECT_FALSE(sem.tryWait());
    asm_volatile_memory();
  }
}

BENCHMARK	(	single_thread_posix_postwait	,
		iters
	)

Definition at line 376 of file LifoSemTests.cpp.

References EXPECT_EQ.

                                               {
  sem_t sem;
  EXPECT_EQ(sem_init(&sem, 0, 0), 0);
  for (size_t n = 0; n < iters; ++n) {
    EXPECT_EQ(sem_post(&sem), 0);
    EXPECT_EQ(sem_wait(&sem), 0);
  }
  EXPECT_EQ(sem_destroy(&sem), 0);
}

BENCHMARK	(	single_thread_posix_trywait	,
		iters
	)

Definition at line 386 of file LifoSemTests.cpp.

References EXPECT_EQ.

                                              {
  sem_t sem;
  EXPECT_EQ(sem_init(&sem, 0, 0), 0);
  for (size_t n = 0; n < iters; ++n) {
    EXPECT_EQ(sem_trywait(&sem), -1);
  }
  EXPECT_EQ(sem_destroy(&sem), 0);
}

BENCHMARK_DRAW_LINE

(

)

static void contendedUse ( uint32_t  n, int  posters, int  waiters  )

static

Definition at line 395 of file LifoSemTests.cpp.

References folly::BENCHMARK_DRAW_LINE(), BENCHMARK_NAMED_PARAM, BENCHMARK_SUSPEND, i, folly::detail::LifoSemBase< BatonType, Atom >::post(), folly::pushmi::detail::t, threads, uint32_t, folly::detail::LifoSemBase< BatonType, Atom >::wait(), and folly::fibers::yield().

                                                               {
  LifoSemImpl<std::atomic> sem;

  std::vector<std::thread> threads;
  std::atomic<bool> go(false);

  BENCHMARK_SUSPEND {
    for (int t = 0; t < waiters; ++t) {
      threads.emplace_back([=, &sem] {
        for (uint32_t i = t; i < n; i += waiters) {
          sem.wait();
        }
      });
    }
    for (int t = 0; t < posters; ++t) {
      threads.emplace_back([=, &sem, &go] {
        while (!go.load()) {
          std::this_thread::yield();
        }
        for (uint32_t i = t; i < n; i += posters) {
          sem.post();
        }
      });
    }
  }

  go.store(true);
  for (auto& thr : threads) {
    thr.join();
  }
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 465 of file LifoSemTests.cpp.

References argv, testing::InitGoogleTest(), RUN_ALL_TESTS(), and folly::runBenchmarksOnFlag().

                                {
  testing::InitGoogleTest(&argc, argv);
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  int rv = RUN_ALL_TESTS();
  folly::runBenchmarksOnFlag();
  return rv;
}

TEST	(	LifoSem	,
		basic
	)

Definition at line 44 of file LifoSemTests.cpp.

References EXPECT_FALSE, EXPECT_TRUE, folly::detail::LifoSemBase< Handoff, Atom >::post(), folly::detail::LifoSemBase< Handoff, Atom >::tryWait(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                     {
  LifoSem sem;
  EXPECT_FALSE(sem.tryWait());
  sem.post();
  EXPECT_TRUE(sem.tryWait());
  sem.post();
  sem.wait();
}

TEST	(	LifoSem	,
		multi
	)

Definition at line 53 of file LifoSemTests.cpp.

References b, i, folly::INFO, folly::detail::LifoSemBase< Handoff, Atom >::post(), threads, folly::detail::LifoSemBase< Handoff, Atom >::tryWait(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                     {
  LifoSem sem;

  const int opsPerThread = 10000;
  std::thread threads[10];
  std::atomic<int> blocks(0);

  for (auto& thr : threads) {
    thr = std::thread([&] {
      int b = 0;
      for (int i = 0; i < opsPerThread; ++i) {
        if (!sem.tryWait()) {
          sem.wait();
          ++b;
        }
        sem.post();
      }
      blocks += b;
    });
  }

  // start the flood
  sem.post();

  for (auto& thr : threads) {
    thr.join();
  }

  LOG(INFO) << opsPerThread * sizeof(threads) / sizeof(threads[0])
            << " post/wait pairs, " << blocks << " blocked";
}

TEST	(	LifoSem	,
		multi_try_wait_simple
	)

Definition at line 222 of file LifoSemTests.cpp.

References ASSERT_EQ, folly::detail::LifoSemBase< Handoff, Atom >::post(), and folly::detail::LifoSemBase< Handoff, Atom >::tryWait().

                                     {
  LifoSem sem;
  sem.post(5);
  auto n = sem.tryWait(10); // this used to trigger an assert
  ASSERT_EQ(5, n);
}

TEST_F	(	LifoSemTest	,
		pingpong
	)

Definition at line 85 of file LifoSemTests.cpp.

References a, b, EXPECT_EQ, i, folly::test::DeterministicSchedule::join(), folly::detail::LifoSemBase< Handoff, Atom >::post(), folly::test::DeterministicSchedule::thread(), folly::test::DeterministicSchedule::uniform(), folly::detail::LifoSemBase< Handoff, Atom >::valueGuess(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                              {
  DSched sched(DSched::uniform(0));

  const int iters = 100;

  for (int pass = 0; pass < 10; ++pass) {
    DLifoSem a;
    DLifoSem b;

    auto thr = DSched::thread([&] {
      for (int i = 0; i < iters; ++i) {
        a.wait();
        // main thread can't be running here
        EXPECT_EQ(a.valueGuess(), 0);
        EXPECT_EQ(b.valueGuess(), 0);
        b.post();
      }
    });
    for (int i = 0; i < iters; ++i) {
      a.post();
      b.wait();
      // child thread can't be running here
      EXPECT_EQ(a.valueGuess(), 0);
      EXPECT_EQ(b.valueGuess(), 0);
    }
    DSched::join(thr);
  }
}

TEST_F	(	LifoSemTest	,
		mutex
	)

Definition at line 114 of file LifoSemTests.cpp.

References a, i, folly::test::DeterministicSchedule::join(), folly::detail::LifoSemBase< Handoff, Atom >::post(), folly::test::DeterministicSchedule::thread(), folly::test::DeterministicSchedule::uniform(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                           {
  DSched sched(DSched::uniform(0));

  const int iters = 100;

  for (int pass = 0; pass < 10; ++pass) {
    DLifoSem a;

    auto thr = DSched::thread([&] {
      for (int i = 0; i < iters; ++i) {
        a.wait();
        a.post();
      }
    });
    for (int i = 0; i < iters; ++i) {
      a.post();
      a.wait();
    }
    a.post();
    DSched::join(thr);
    a.wait();
  }
}

TEST_F	(	LifoSemTest	,
		no_blocking
	)

Definition at line 138 of file LifoSemTests.cpp.

References a, i, folly::INFO, folly::test::DeterministicSchedule::join(), folly::detail::LifoSemBase< Handoff, Atom >::post(), folly::randomNumberSeed(), seed, folly::test::DeterministicSchedule::thread(), threads, folly::test::DeterministicSchedule::uniform(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                                 {
  long seed = folly::randomNumberSeed() % 10000;
  LOG(INFO) << "seed=" << seed;
  DSched sched(DSched::uniform(seed));

  const int iters = 100;
  const int numThreads = 2;
  const int width = 10;

  for (int pass = 0; pass < 10; ++pass) {
    DLifoSem a;

    std::vector<std::thread> threads;
    while (threads.size() < numThreads) {
      threads.emplace_back(DSched::thread([&] {
        for (int i = 0; i < iters; ++i) {
          a.post(width);
          for (int w = 0; w < width; ++w) {
            a.wait();
          }
        }
      }));
    }
    for (auto& thr : threads) {
      DSched::join(thr);
    }
  }
}

TEST_F	(	LifoSemTest	,
		one_way
	)

Definition at line 167 of file LifoSemTests.cpp.

References a, i, folly::INFO, folly::test::DeterministicSchedule::join(), folly::detail::LifoSemBase< Handoff, Atom >::post(), folly::randomNumberSeed(), seed, folly::test::DeterministicSchedule::thread(), folly::test::DeterministicSchedule::uniformSubset(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                             {
  long seed = folly::randomNumberSeed() % 10000;
  LOG(INFO) << "seed=" << seed;
  DSched sched(DSched::uniformSubset(seed, 1, 6));

  const int iters = 1000;

  for (int pass = 0; pass < 10; ++pass) {
    DLifoSem a;

    auto thr = DSched::thread([&] {
      for (int i = 0; i < iters; ++i) {
        a.wait();
      }
    });
    for (int i = 0; i < iters; ++i) {
      a.post();
    }
    DSched::join(thr);
  }
}

TEST_F	(	LifoSemTest	,
		shutdown_wait_order
	)

Definition at line 189 of file LifoSemTests.cpp.

References a, EXPECT_THROW, EXPECT_TRUE, folly::detail::LifoSemBase< Handoff, Atom >::isShutdown(), folly::detail::LifoSemBase< Handoff, Atom >::post(), folly::detail::LifoSemBase< Handoff, Atom >::shutdown(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                                         {
  DLifoSem a;
  a.shutdown();
  a.post();
  a.wait();
  EXPECT_THROW(a.wait(), ShutdownSemError);
  EXPECT_TRUE(a.isShutdown());
}

TEST_F	(	LifoSemTest	,
		shutdown_multi
	)

Definition at line 198 of file LifoSemTests.cpp.

References a, ADD_FAILURE, EXPECT_TRUE, folly::detail::LifoSemBase< Handoff, Atom >::isShutdown(), folly::test::DeterministicSchedule::join(), folly::detail::LifoSemBase< Handoff, Atom >::shutdown(), folly::test::DeterministicSchedule::thread(), threads, folly::test::DeterministicSchedule::uniform(), and folly::detail::LifoSemBase< Handoff, Atom >::wait().

                                    {
  DSched sched(DSched::uniform(0));

  for (int pass = 0; pass < 10; ++pass) {
    DLifoSem a;
    std::vector<std::thread> threads;
    while (threads.size() < 20) {
      threads.push_back(DSched::thread([&] {
        try {
          a.wait();
          ADD_FAILURE();
        } catch (ShutdownSemError&) {
          // expected
          EXPECT_TRUE(a.isShutdown());
        }
      }));
    }
    a.shutdown();
    for (auto& thr : threads) {
      DSched::join(thr);
    }
  }
}

TEST_F	(	LifoSemTest	,
		multi_try_wait
	)

Definition at line 229 of file LifoSemTests.cpp.

References ASSERT_EQ, i, folly::INFO, folly::test::DeterministicSchedule::join(), folly::test::DeterministicAtomicImpl< T, Schedule, Atom >::load(), folly::detail::LifoSemBase< Handoff, Atom >::post(), folly::randomNumberSeed(), seed, stop(), folly::test::DeterministicAtomicImpl< T, Schedule, Atom >::store(), folly::test::DeterministicSchedule::thread(), folly::detail::LifoSemBase< Handoff, Atom >::tryWait(), and folly::test::DeterministicSchedule::uniform().

                                    {
  long seed = folly::randomNumberSeed() % 10000;
  LOG(INFO) << "seed=" << seed;
  DSched sched(DSched::uniform(seed));
  DLifoSem sem;

  const int NPOSTS = 1000;

  auto producer = [&] {
    for (int i = 0; i < NPOSTS; ++i) {
      sem.post();
    }
  };

  DeterministicAtomic<bool> consumer_stop(false);
  int consumed = 0;

  auto consumer = [&] {
    bool stop;
    do {
      stop = consumer_stop.load();
      int n;
      do {
        n = sem.tryWait(10);
        consumed += n;
      } while (n > 0);
    } while (!stop);
  };

  std::thread producer_thread(DSched::thread(producer));
  std::thread consumer_thread(DSched::thread(consumer));
  DSched::join(producer_thread);
  consumer_stop.store(true);
  DSched::join(consumer_thread);

  ASSERT_EQ(NPOSTS, consumed);
}

TEST_F	(	LifoSemTest	,
		timeout
	)

Definition at line 267 of file LifoSemTests.cpp.

References a, EXPECT_GT, EXPECT_TRUE, i, folly::INFO, folly::detail::LifoSemBase< Handoff, Atom >::isShutdown(), folly::test::DeterministicSchedule::join(), folly::detail::LifoSemBase< Handoff, Atom >::post(), folly::randomNumberSeed(), seed, folly::detail::LifoSemBase< Handoff, Atom >::shutdown(), folly::test::DeterministicSchedule::thread(), threads, folly::detail::LifoSemBase< Handoff, Atom >::try_wait_for(), and folly::test::DeterministicSchedule::uniform().

                             {
  long seed = folly::randomNumberSeed() % 10000;
  LOG(INFO) << "seed=" << seed;
  DSched sched(DSched::uniform(seed));
  DeterministicAtomic<uint32_t> handoffs{0};

  for (int pass = 0; pass < 10; ++pass) {
    DLifoSem a;
    std::vector<std::thread> threads;
    while (threads.size() < 20) {
      threads.push_back(DSched::thread([&] {
        for (int i = 0; i < 10; i++) {
          try {
            if (a.try_wait_for(std::chrono::milliseconds(1))) {
              handoffs--;
            }
          } catch (ShutdownSemError&) {
            // expected
            EXPECT_TRUE(a.isShutdown());
          }
        }
      }));
    }
    std::vector<std::thread> threads2;
    while (threads2.size() < 20) {
      threads2.push_back(DSched::thread([&] {
        for (int i = 0; i < 10; i++) {
          a.post();
          handoffs++;
        }
      }));
    }
    if (pass > 5) {
      a.shutdown();
    }
    for (auto& thr : threads) {
      DSched::join(thr);
    }
    for (auto& thr : threads2) {
      DSched::join(thr);
    }
    // At least one timeout must occur.
    EXPECT_GT(handoffs.load(), 0);
  }
}