folly库高性能futex源码探究

Futex（快速用户空间互斥量）是一个32位的无符号整型原子变量，它允许对该值执行futex()系统调用。它以模板化的方式设计，使其能够与确定性调度测试（DeterministicSchedule）正确交互。

h源码：

enum class FutexResult {
  VALUE_CHANGED, /* futex value didn't match expected */
  AWOKEN,        /* wakeup by matching futex wake, or spurious wakeup */
  INTERRUPTED,   /* wakeup by interrupting signal */
  TIMEDOUT,      /* wakeup by expiring deadline */
};

/**
 * Futex is an atomic 32 bit unsigned integer that provides access to the
 * futex() syscall on that value.  It is templated in such a way that it
 * can interact properly with DeterministicSchedule testing.
 *
 * If you don't know how to use futex(), you probably shouldn't be using
 * this class.  Even if you do know how, you should have a good reason
 * (and benchmarks to back you up).
 */
template <template <typename> class Atom = std::atomic>
struct Futex : Atom<uint32_t> {
  Futex() : Atom<uint32_t>() {}

  explicit constexpr Futex(uint32_t init) : Atom<uint32_t>(init) {}

  /** Puts the thread to sleep if this->load() == expected.  Returns true when
   *  it is returning because it has consumed a wake() event, false for any
   *  other return (signal, this->load() != expected, or spurious wakeup). */
  FutexResult futexWait(uint32_t expected, uint32_t waitMask = -1) {
    auto rv = futexWaitImpl(expected, nullptr, nullptr, waitMask);
    assert(rv != FutexResult::TIMEDOUT);
    return rv;
  }

  /** Similar to futexWait but also accepts a deadline until when the wait call
   *  may block.
   *
   *  Optimal clock types: std::chrono::system_clock, std::chrono::steady_clock.
   *  NOTE: On some systems steady_clock is just an alias for system_clock,
   *  and is not actually steady.
   *
   *  For any other clock type, now() will be invoked twice. */
  template <class Clock, class Duration = typename Clock::duration>
  FutexResult futexWaitUntil(
      uint32_t expected,
      std::chrono::time_point<Clock, Duration> const& deadline,
      uint32_t waitMask = -1) {
    using Target = typename std::conditional<
        Clock::is_steady,
        std::chrono::steady_clock,
        std::chrono::system_clock>::type;
    auto const converted = time_point_conv<Target>(deadline);
    return converted == Target::time_point::max()
        ? futexWaitImpl(expected, nullptr, nullptr, waitMask)
        : futexWaitImpl(expected, converted, waitMask);
  }

  /** Wakens up to count waiters where (waitMask & wakeMask) !=
   *  0, returning the number of awoken threads, or -1 if an error
   *  occurred.  Note that when constructing a concurrency primitive
   *  that can guard its own destruction, it is likely that you will
   *  want to ignore EINVAL here (as well as making sure that you
   *  never touch the object after performing the memory store that
   *  is the linearization point for unlock or control handoff).
   *  See https://sourceware.org/bugzilla/show_bug.cgi?id=13690 */
  int futexWake(int count = std::numeric_limits<int>::max(),
                uint32_t wakeMask = -1);

 private:
  /** Optimal when TargetClock is the same type as Clock.
   *
   *  Otherwise, both Clock::now() and TargetClock::now() must be invoked. */
  template <typename TargetClock, typename Clock, typename Duration>
  static typename TargetClock::time_point time_point_conv(
      std::chrono::time_point<Clock, Duration> const& time) {
    using std::chrono::duration_cast;
    using TimePoint = std::chrono::time_point<Clock, Duration>;
    using TargetDuration = typename TargetClock::duration;
    using TargetTimePoint = typename TargetClock::time_point;
    if (time == TimePoin