FutexTest.cpp File Reference

#include <folly/detail/Futex.h>
#include <folly/test/DeterministicSchedule.h>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <ratio>
#include <thread>
#include <glog/logging.h>
#include <folly/Chrono.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Time.h>

Go to the source code of this file.

Typedefs
typedef DeterministicSchedule	DSched

Functions
template<template< typename > class Atom>
void	run_basic_thread (Futex< Atom > &f)
template<template< typename > class Atom>
void	run_basic_tests ()
template<template< typename > class Atom, typename Clock , typename Duration >
void	liveClockWaitUntilTests ()
template<typename Clock >
void	deterministicAtomicWaitUntilTests ()
template<template< typename > class Atom>
void	run_wait_until_tests ()
template<>
void	run_wait_until_tests< DeterministicAtomic > ()
uint64_t	diff (uint64_t a, uint64_t b)
void	run_system_clock_test ()
void	run_steady_clock_test ()
template<template< typename > class Atom>
void	run_wake_blocked_test ()
	TEST (Futex, clock_source)
	TEST (Futex, basic_live)
	TEST (Futex, basic_emulated)
	TEST (Futex, basic_deterministic)
	TEST (Futex, wake_blocked_live)
	TEST (Futex, wake_blocked_emulated)

Typedef Documentation

typedef DeterministicSchedule DSched

Definition at line 38 of file FutexTest.cpp.

Function Documentation

template<typename Clock >

void deterministicAtomicWaitUntilTests

(

)

Definition at line 109 of file FutexTest.cpp.

References Atom, EXPECT_TRUE, f, folly::detail::futexWaitUntil(), folly::detail::INTERRUPTED, now(), and folly::detail::TIMEDOUT.

                                         {
  Futex<DeterministicAtomic> f(0);

  // Futex wait must eventually fail with either FutexResult::TIMEDOUT or
  // FutexResult::INTERRUPTED
  const auto res = futexWaitUntil(&f, 0, Clock::now() + milliseconds(100));
  EXPECT_TRUE(res == FutexResult::TIMEDOUT || res == FutexResult::INTERRUPTED);
}

uint64_t diff	(	uint64_t	a,
		uint64_t	b
	)

Definition at line 135 of file FutexTest.cpp.

References a.

Referenced by testing::internal::DoubleNearPredFormat(), folly::UnboundedQueue< T, false, 6 >::getAllocNextSegment(), proxygen::HTTPCommonHeaders::getHeaderCodeFromTableCommonHeaderName(), testing::gmock_matchers_test::GreaterThanMatcher::MatchAndExplain(), testing::internal::FloatingEqMatcher< FloatType >::Impl< T >::MatchAndExplain(), folly::dynamic::merge_diff(), folly::detail::BufferedSlidingWindow< DigestT, ClockT >::onNewDigest(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::release_external(), run_system_clock_test(), runFairness(), folly::HHWheelTimer::scheduleTimeoutImpl(), proxygen::Window::setCapacity(), TEST(), and updateModifiedTime().

                                      {
  return a > b ? a - b : b - a;
}

template<template< typename > class Atom, typename Clock , typename Duration >

void liveClockWaitUntilTests

(

)

Definition at line 62 of file FutexTest.cpp.

References folly::detail::AWOKEN, count, EXPECT_EQ, EXPECT_TRUE, f, folly::detail::futexWaitUntil(), folly::detail::futexWake(), folly::test::DeterministicSchedule::join(), now(), start, folly::test::DeterministicSchedule::thread(), folly::detail::TIMEDOUT, and folly::fibers::yield().

                               {
  Futex<Atom> f(0);

  for (int stress = 0; stress < 1000; ++stress) {
    auto fp = &f; // workaround for t5336595
    auto thrA = DSched::thread([fp, stress] {
      while (true) {
        const auto deadline = time_point_cast<Duration>(
            Clock::now() + microseconds(1 << (stress % 20)));
        const auto res = futexWaitUntil(fp, 0, deadline);
        EXPECT_TRUE(res == FutexResult::TIMEDOUT || res == FutexResult::AWOKEN);
        if (res == FutexResult::AWOKEN) {
          break;
        }
      }
    });

    while (futexWake(&f) != 1) {
      std::this_thread::yield();
    }

    DSched::join(thrA);
  }

  {
    const auto start = Clock::now();
    const auto deadline = time_point_cast<Duration>(start + milliseconds(100));
    EXPECT_EQ(futexWaitUntil(&f, 0, deadline), FutexResult::TIMEDOUT);
    LOG(INFO) << "Futex wait timed out after waiting for "
              << duration_cast<milliseconds>(Clock::now() - start).count()
              << "ms using clock with " << Duration::period::den
              << " precision, should be ~100ms";
  }

  {
    const auto start = Clock::now();
    const auto deadline =
        time_point_cast<Duration>(start - 2 * start.time_since_epoch());
    EXPECT_EQ(futexWaitUntil(&f, 0, deadline), FutexResult::TIMEDOUT);
    LOG(INFO) << "Futex wait with invalid deadline timed out after waiting for "
              << duration_cast<milliseconds>(Clock::now() - start).count()
              << "ms using clock with " << Duration::period::den
              << " precision, should be ~0ms";
  }
}

template<template< typename > class Atom>

void run_basic_tests

(

)

Definition at line 46 of file FutexTest.cpp.

References Atom, folly::netops::bind(), EXPECT_EQ, f, folly::detail::futexWait(), folly::detail::futexWake(), folly::test::DeterministicSchedule::join(), folly::test::DeterministicSchedule::thread(), folly::detail::VALUE_CHANGED, and folly::fibers::yield().

                       {
  Futex<Atom> f(0);

  EXPECT_EQ(FutexResult::VALUE_CHANGED, futexWait(&f, 1));
  EXPECT_EQ(futexWake(&f), 0);

  auto thr = DSched::thread(std::bind(run_basic_thread<Atom>, std::ref(f)));

  while (futexWake(&f) != 1) {
    std::this_thread::yield();
  }

  DSched::join(thr);
}

template<template< typename > class Atom>

void run_basic_thread

(

Futex< Atom > &

f

)

Definition at line 41 of file FutexTest.cpp.

References Atom, folly::detail::AWOKEN, EXPECT_EQ, and folly::detail::futexWait().

                                      {
  EXPECT_EQ(FutexResult::AWOKEN, futexWait(&f, 0));
}

void run_steady_clock_test

(

)

Definition at line 172 of file FutexTest.cpp.

References Atom, B, C, folly::chrono::clock_gettime, count, EXPECT_TRUE, now(), and uint64_t.

Referenced by TEST().

                             {
  /* Test to verify that steady_clock uses clock_gettime(CLOCK_MONOTONIC, ...)
   * for the time_points */
  EXPECT_TRUE(steady_clock::is_steady);

  const uint64_t A =
      duration_cast<nanoseconds>(steady_clock::now().time_since_epoch())
          .count();

  struct timespec ts;
  clock_gettime(CLOCK_MONOTONIC, &ts);
  const uint64_t B = ts.tv_sec * 1000000000ULL + ts.tv_nsec;

  const uint64_t C =
      duration_cast<nanoseconds>(steady_clock::now().time_since_epoch())
          .count();
  EXPECT_TRUE(A <= B && B <= C);
}

void run_system_clock_test

(

)

The following loop is only to make the test more robust in the presence of clock adjustments that can occur. We just run the loop maxIter times and expect with very high probability that there will be atleast one iteration of the test during which clock adjustments > delta have not occurred.

Definition at line 139 of file FutexTest.cpp.

References a, b, c, folly::chrono::clock_gettime, count, diff(), EXPECT_TRUE, now(), and uint64_t.

Referenced by TEST().

                             {
  /* Test to verify that system_clock uses clock_gettime(CLOCK_REALTIME, ...)
   * for the time_points */
  struct timespec ts;
  const int maxIters = 1000;
  int iter = 0;
  const uint64_t delta = 10000000 /* 10 ms */;

  while (iter < maxIters) {
    uint64_t a =
        duration_cast<nanoseconds>(system_clock::now().time_since_epoch())
            .count();

    clock_gettime(CLOCK_REALTIME, &ts);
    uint64_t b = ts.tv_sec * 1000000000ULL + ts.tv_nsec;

    uint64_t c =
        duration_cast<nanoseconds>(system_clock::now().time_since_epoch())
            .count();

    if (diff(a, b) <= delta && diff(b, c) <= delta && diff(a, c) <= 2 * delta) {
      /* Success! system_clock uses CLOCK_REALTIME for time_points */
      break;
    }
    iter++;
  }
  EXPECT_TRUE(iter < maxIters);
}

template<template< typename > class Atom>

void run_wait_until_tests

(

)

Definition at line 119 of file FutexTest.cpp.

                            {
  liveClockWaitUntilTests<Atom, system_clock, system_clock::duration>();
  liveClockWaitUntilTests<Atom, steady_clock, steady_clock::duration>();
  liveClockWaitUntilTests<Atom, steady_clock, coarse_steady_clock::duration>();

  typedef duration<int64_t, std::ratio<1, 10000000>> decimicroseconds;
  liveClockWaitUntilTests<Atom, system_clock, decimicroseconds>();
}

template<>

void run_wait_until_tests< DeterministicAtomic >

(

)

Definition at line 129 of file FutexTest.cpp.

Referenced by TEST().

                                                 {
  deterministicAtomicWaitUntilTests<system_clock>();
  deterministicAtomicWaitUntilTests<steady_clock>();
  deterministicAtomicWaitUntilTests<coarse_steady_clock>();
}

template<template< typename > class Atom>

void run_wake_blocked_test

(

)

Definition at line 192 of file FutexTest.cpp.

References folly::detail::AWOKEN, f, folly::detail::futexWait(), folly::detail::futexWake(), folly::test::DeterministicSchedule::join(), folly::detail::success, and folly::test::DeterministicSchedule::thread().

                             {
  for (auto delay = std::chrono::milliseconds(1);; delay *= 2) {
    bool success = false;
    Futex<Atom> f(0);
    auto thr = DSched::thread(
        [&] { success = FutexResult::AWOKEN == futexWait(&f, 0); });
    /* sleep override */ std::this_thread::sleep_for(delay);
    f.store(1);
    futexWake(&f, 1);
    DSched::join(thr);
    LOG(INFO) << "delay=" << delay.count() << "_ms, success=" << success;
    if (success) {
      break;
    }
  }
}

TEST	(	Futex	,
		clock_source
	)

Definition at line 209 of file FutexTest.cpp.

References run_steady_clock_test(), run_system_clock_test(), and value.

                          {
  run_system_clock_test();

  /* On some systems steady_clock is just an alias for system_clock. So,
   * we must skip run_steady_clock_test if the two clocks are the same. */
  if (!std::is_same<system_clock, steady_clock>::value) {
    run_steady_clock_test();
  }
}

TEST	(	Futex	,
		basic_live
	)

Definition at line 219 of file FutexTest.cpp.

                        {
  run_basic_tests<std::atomic>();
  run_wait_until_tests<std::atomic>();
}

TEST	(	Futex	,
		basic_emulated
	)

Definition at line 224 of file FutexTest.cpp.

                            {
  run_basic_tests<EmulatedFutexAtomic>();
  run_wait_until_tests<EmulatedFutexAtomic>();
}

TEST	(	Futex	,
		basic_deterministic
	)

Definition at line 229 of file FutexTest.cpp.

References run_wait_until_tests< DeterministicAtomic >(), and folly::test::DeterministicSchedule::uniform().

                                 {
  DSched sched(DSched::uniform(0));
  run_basic_tests<DeterministicAtomic>();
  run_wait_until_tests<DeterministicAtomic>();
}

TEST	(	Futex	,
		wake_blocked_live
	)

Definition at line 235 of file FutexTest.cpp.

                               {
  run_wake_blocked_test<std::atomic>();
}

TEST	(	Futex	,
		wake_blocked_emulated
	)

Definition at line 239 of file FutexTest.cpp.

                                   {
  run_wake_blocked_test<EmulatedFutexAtomic>();
}