X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2Fwangle%2FFuture-inl.h;h=cf10e9f466a280c5b3d68a8992a4c97878ff75ec;hb=ff25b9504aa16da11906eb2807fd37127cb7c538;hp=a8f5b94bb1da2d162981b43d9fbacd521f00d70f;hpb=73e3273b9f2f2f5686e2b6ff4a87d572f2391585;p=folly.git

diff --git a/folly/wangle/Future-inl.h b/folly/wangle/Future-inl.h
index a8f5b94b..cf10e9f4 100644
--- a/folly/wangle/Future-inl.h
+++ b/folly/wangle/Future-inl.h
@@ -16,8 +16,11 @@
 
 #pragma once
 
-#include "detail/State.h"
-#include <folly/LifoSem.h>
+#include <chrono>
+#include <thread>
+
+#include <folly/wangle/detail/Core.h>
+#include <folly/Baton.h>
 
 namespace folly { namespace wangle {
 
@@ -32,13 +35,13 @@ struct isFuture<Future<T> > {
 };
 
 template <class T>
-Future<T>::Future(Future<T>&& other) noexcept : state_(nullptr) {
+Future<T>::Future(Future<T>&& other) noexcept : core_(nullptr) {
   *this = std::move(other);
 }
 
 template <class T>
 Future<T>& Future<T>::operator=(Future<T>&& other) {
-  std::swap(state_, other.state_);
+  std::swap(core_, other.core_);
   return *this;
 }
 
@@ -49,15 +52,15 @@ Future<T>::~Future() {
 
 template <class T>
 void Future<T>::detach() {
-  if (state_) {
-    state_->detachFuture();
-    state_ = nullptr;
+  if (core_) {
+    core_->detachFuture();
+    core_ = nullptr;
   }
 }
 
 template <class T>
 void Future<T>::throwIfInvalid() const {
-  if (!state_)
+  if (!core_)
     throw NoState();
 }
 
@@ -65,7 +68,7 @@ template <class T>
 template <class F>
 void Future<T>::setCallback_(F&& func) {
   throwIfInvalid();
-  state_->setCallback(std::move(func));
+  core_->setCallback(std::move(func));
 }
 
 template <class T>
@@ -92,10 +95,10 @@ Future<T>::then(F&& func) {
      sophisticated that avoids making a new Future object when it can, as an
      optimization. But this is correct.
 
-     state_ can't be moved, it is explicitly disallowed (as is copying). But
+     core_ can't be moved, it is explicitly disallowed (as is copying). But
      if there's ever a reason to allow it, this is one place that makes that
      assumption and would need to be fixed. We use a standard shared pointer
-     for state_ (by copying it in), which means in essence obj holds a shared
+     for core_ (by copying it in), which means in essence obj holds a shared
      pointer to itself.  But this shouldn't leak because Promise will not
      outlive the continuation, because Promise will setException() with a
      broken Promise if it is destructed before completed. We could use a
@@ -107,11 +110,11 @@ Future<T>::then(F&& func) {
      We have to move in the Promise and func using the MoveWrapper
      hack. (func could be copied but it's a big drag on perf).
 
-     Two subtle but important points about this design. detail::State has no
+     Two subtle but important points about this design. detail::Core has no
      back pointers to Future or Promise, so if Future or Promise get moved
      (and they will be moved in performant code) we don't have to do
      anything fancy. And because we store the continuation in the
-     detail::State, not in the Future, we can execute the continuation even
+     detail::Core, not in the Future, we can execute the continuation even
      after the Future has gone out of scope. This is an intentional design
      decision. It is likely we will want to be able to cancel a continuation
      in some circumstances, but I think it should be explicit not implicit
@@ -169,42 +172,38 @@ template <class T>
 typename std::add_lvalue_reference<T>::type Future<T>::value() {
   throwIfInvalid();
 
-  return state_->value();
+  return core_->value();
 }
 
 template <class T>
 typename std::add_lvalue_reference<const T>::type Future<T>::value() const {
   throwIfInvalid();
 
-  return state_->value();
+  return core_->value();
 }
 
 template <class T>
 Try<T>& Future<T>::getTry() {
   throwIfInvalid();
 
-  return state_->getTry();
+  return core_->getTry();
 }
 
 template <class T>
 template <typename Executor>
 inline Future<T> Future<T>::via(Executor* executor) {
   throwIfInvalid();
-  auto f = then([=](Try<T>&& t) {
-    MoveWrapper<Promise<T>> promise;
-    MoveWrapper<Try<T>> tw(std::move(t));
-    auto f = promise->getFuture();
-    executor->add([=]() mutable { promise->fulfilTry(std::move(*tw)); });
-    return f;
-  });
-  f.deactivate();
-  return f;
+
+  this->deactivate();
+  core_->setExecutor(executor);
+
+  return std::move(*this);
 }
 
 template <class T>
 bool Future<T>::isReady() const {
   throwIfInvalid();
-  return state_->ready();
+  return core_->ready();
 }
 
 // makeFuture
@@ -254,7 +253,8 @@ Future<T> makeFuture(std::exception_ptr const& e) {
 }
 
 template <class T, class E>
-typename std::enable_if<std::is_base_of<std::exception, E>::value, Future<T>>::type
+typename std::enable_if<std::is_base_of<std::exception, E>::value,
+                        Future<T>>::type
 makeFuture(E const& e) {
   Promise<T> p;
   auto f = p.getFuture();
@@ -408,61 +408,59 @@ whenN(InputIterator first, InputIterator last, size_t n) {
 template <typename T>
 Future<T>
 waitWithSemaphore(Future<T>&& f) {
-  LifoSem sem;
+  Baton<> baton;
   auto done = f.then([&](Try<T> &&t) {
-    sem.post();
+    baton.post();
     return std::move(t.value());
   });
-  sem.wait();
+  baton.wait();
+  while (!done.isReady()) {
+    // There's a race here between the return here and the actual finishing of
+    // the future. f is completed, but the setup may not have finished on done
+    // after the baton has posted.
+    std::this_thread::yield();
+  }
   return done;
 }
 
 template<>
 inline Future<void> waitWithSemaphore<void>(Future<void>&& f) {
-  LifoSem sem;
+  Baton<> baton;
   auto done = f.then([&](Try<void> &&t) {
-    sem.post();
+    baton.post();
     t.value();
   });
-  sem.wait();
+  baton.wait();
+  while (!done.isReady()) {
+    // There's a race here between the return here and the actual finishing of
+    // the future. f is completed, but the setup may not have finished on done
+    // after the baton has posted.
+    std::this_thread::yield();
+  }
   return done;
 }
 
 template <typename T, class Duration>
 Future<T>
 waitWithSemaphore(Future<T>&& f, Duration timeout) {
-  auto sem = std::make_shared<LifoSem>();
-  auto done = f.then([sem](Try<T> &&t) {
-    sem->post();
+  auto baton = std::make_shared<Baton<>>();
+  auto done = f.then([baton](Try<T> &&t) {
+    baton->post();
     return std::move(t.value());
   });
-  std::thread t([sem, timeout](){
-    std::this_thread::sleep_for(timeout);
-    sem->shutdown();
-    });
-  t.detach();
-  try {
-    sem->wait();
-  } catch (ShutdownSemError & ign) { }
+  baton->timed_wait(std::chrono::system_clock::now() + timeout);
   return done;
 }
 
 template <class Duration>
 Future<void>
 waitWithSemaphore(Future<void>&& f, Duration timeout) {
-  auto sem = std::make_shared<LifoSem>();
-  auto done = f.then([sem](Try<void> &&t) {
-    sem->post();
+  auto baton = std::make_shared<Baton<>>();
+  auto done = f.then([baton](Try<void> &&t) {
+    baton->post();
     t.value();
   });
-  std::thread t([sem, timeout](){
-    std::this_thread::sleep_for(timeout);
-    sem->shutdown();
-    });
-  t.detach();
-  try {
-    sem->wait();
-  } catch (ShutdownSemError & ign) { }
+  baton->timed_wait(std::chrono::system_clock::now() + timeout);
   return done;
 }