X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2Fdetail%2FFutex.h;h=de0c78f9bef0438c006af86eecf90a84477c40e9;hb=8893b8bcd26b41471e77c6882d77404c9a617176;hp=fe61d0e66417081fcc45c5a569b3b492acbf0306;hpb=d3ee675ff41cd36587ba8de41568050baa08eb3e;p=folly.git

diff --git a/folly/detail/Futex.h b/folly/detail/Futex.h
index fe61d0e6..de0c78f9 100644
--- a/folly/detail/Futex.h
+++ b/folly/detail/Futex.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014 Facebook, Inc.
+ * Copyright 2013-present Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,19 +17,20 @@
 #pragma once
 
 #include <atomic>
+#include <cassert>
 #include <chrono>
 #include <limits>
-#include <assert.h>
-#include <unistd.h>
-#include <boost/noncopyable.hpp>
+#include <type_traits>
+
+#include <folly/portability/Unistd.h>
 
 namespace folly { namespace detail {
 
 enum class FutexResult {
-  VALUE_CHANGED, /* Futex value didn't match expected */
-  AWOKEN,        /* futex wait matched with a futex wake */
-  INTERRUPTED,   /* Spurious wake-up or signal caused futex wait failure */
-  TIMEDOUT
+  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 */
 };
 
 /**
@@ -42,60 +43,88 @@ enum class FutexResult {
  * (and benchmarks to back you up).
  */
 template <template <typename> class Atom = std::atomic>
-struct Futex : Atom<uint32_t>, boost::noncopyable {
-
-  explicit Futex(uint32_t init = 0) : Atom<uint32_t>(init) {}
+struct Futex : Atom<uint32_t> {
+  using Atom<uint32_t>::Atom;
 
   /** 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). */
-  bool futexWait(uint32_t expected, uint32_t waitMask = -1) {
+  FutexResult futexWait(uint32_t expected, uint32_t waitMask = -1) {
     auto rv = futexWaitImpl(expected, nullptr, nullptr, waitMask);
     assert(rv != FutexResult::TIMEDOUT);
-    return rv == FutexResult::AWOKEN;
+    return rv;
   }
 
-  /** Similar to futexWait but also accepts a timeout that gives the time until
-   *  when the call can block (time is the absolute time i.e time since epoch).
-   *  Allowed clock types: std::chrono::system_clock, std::chrono::steady_clock.
-   *  Returns one of FutexResult values.
+  /** 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.*/
+   *  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,
-          const std::chrono::time_point<Clock, Duration>& absTime,
-          uint32_t waitMask = -1) {
-    using std::chrono::duration_cast;
-    using std::chrono::nanoseconds;
-    using std::chrono::seconds;
-    using std::chrono::steady_clock;
-    using std::chrono::system_clock;
-    using std::chrono::time_point;
-
-    static_assert(
-        (std::is_same<Clock, system_clock>::value ||
-         std::is_same<Clock, steady_clock>::value),
-        "futexWaitUntil only knows std::chrono::{system_clock,steady_clock}");
-    assert((std::is_same<Clock, system_clock>::value) || Clock::is_steady);
-
-    auto duration = absTime.time_since_epoch();
-    if (std::is_same<Clock, system_clock>::value) {
-      time_point<system_clock> absSystemTime(duration);
-      return futexWaitImpl(expected, &absSystemTime, nullptr, waitMask);
-    } else {
-      time_point<steady_clock> absSteadyTime(duration);
-      return futexWaitImpl(expected, nullptr, &absSteadyTime, waitMask);
-    }
+      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 futexWaitImpl(expected, converted, waitMask);
   }
 
-  /** Wakens up to count waiters where (waitMask & wakeMask) != 0,
-   *  returning the number of awoken threads. */
+  /** 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 TargetDuration = typename TargetClock::duration;
+    using TargetTimePoint = typename TargetClock::time_point;
+    if (std::is_same<Clock, TargetClock>::value) {
+      // in place of time_point_cast, which cannot compile without if-constexpr
+      auto const delta = time.time_since_epoch();
+      return TargetTimePoint(duration_cast<TargetDuration>(delta));
+    } else {
+      // different clocks with different epochs, so non-optimal case
+      auto const delta = time - Clock::now();
+      return TargetClock::now() + duration_cast<TargetDuration>(delta);
+    }
+  }
+
+  template <typename Deadline>
+  typename std::enable_if<Deadline::clock::is_steady, FutexResult>::type
+  futexWaitImpl(
+      uint32_t expected,
+      Deadline const& deadline,
+      uint32_t waitMask) {
+    return futexWaitImpl(expected, nullptr, &deadline, waitMask);
+  }
+
+  template <typename Deadline>
+  typename std::enable_if<!Deadline::clock::is_steady, FutexResult>::type
+  futexWaitImpl(
+      uint32_t expected,
+      Deadline const& deadline,
+      uint32_t waitMask) {
+    return futexWaitImpl(expected, &deadline, nullptr, waitMask);
+  }
 
   /** Underlying implementation of futexWait and futexWaitUntil.
    *  At most one of absSystemTime and absSteadyTime should be non-null.
@@ -105,8 +134,8 @@ struct Futex : Atom<uint32_t>, boost::noncopyable {
    *  is the same as system_clock on some platforms. */
   FutexResult futexWaitImpl(
       uint32_t expected,
-      std::chrono::time_point<std::chrono::system_clock>* absSystemTime,
-      std::chrono::time_point<std::chrono::steady_clock>* absSteadyTime,
+      std::chrono::system_clock::time_point const* absSystemTime,
+      std::chrono::steady_clock::time_point const* absSteadyTime,
       uint32_t waitMask);
 };
 
@@ -118,29 +147,31 @@ struct EmulatedFutexAtomic : public std::atomic<T> {
   EmulatedFutexAtomic() noexcept = default;
   constexpr /* implicit */ EmulatedFutexAtomic(T init) noexcept
       : std::atomic<T>(init) {}
-  EmulatedFutexAtomic(const EmulatedFutexAtomic& rhs) = delete;
+  // It doesn't copy or move
+  EmulatedFutexAtomic(EmulatedFutexAtomic&& rhs) = delete;
 };
 
 /* Available specializations, with definitions elsewhere */
 
-template<>
+template <>
 int Futex<std::atomic>::futexWake(int count, uint32_t wakeMask);
 
-template<>
+template <>
 FutexResult Futex<std::atomic>::futexWaitImpl(
-      uint32_t expected,
-      std::chrono::time_point<std::chrono::system_clock>* absSystemTime,
-      std::chrono::time_point<std::chrono::steady_clock>* absSteadyTime,
-      uint32_t waitMask);
+    uint32_t expected,
+    std::chrono::system_clock::time_point const* absSystemTime,
+    std::chrono::steady_clock::time_point const* absSteadyTime,
+    uint32_t waitMask);
 
-template<>
+template <>
 int Futex<EmulatedFutexAtomic>::futexWake(int count, uint32_t wakeMask);
 
-template<>
+template <>
 FutexResult Futex<EmulatedFutexAtomic>::futexWaitImpl(
-      uint32_t expected,
-      std::chrono::time_point<std::chrono::system_clock>* absSystemTime,
-      std::chrono::time_point<std::chrono::steady_clock>* absSteadyTime,
-      uint32_t waitMask);
+    uint32_t expected,
+    std::chrono::system_clock::time_point const* absSystemTime,
+    std::chrono::steady_clock::time_point const* absSteadyTime,
+    uint32_t waitMask);
 
-}}
+} // namespace detail
+} // namespace folly