explicit instantiation of common Future types

Summary:
Compiling folly/futures:futures-test, this saves 15% (dbg) and 7% (opt)
Compiling all of folly/futures, it's 7% ish for each

Main blocker right now is that this generates a spew of deprecated warnings from calls to core_->(de)activate() from Future::(de)activate(). Can the deprecations be moved up to the Future methods instead?

Also had to fix willEqual for Future<void> which was borked

Test Plan: compiles

Reviewed By: hans@fb.com

Subscribers: trunkagent, folly-diffs@, jsedgwick, yfeldblum, chalfant

FB internal diff: D2021028

Signature: t1:2021028:1430749114:1dd78af47ea91aa5e67929a5884b66ca0c8ae2d8

diff --git a/folly/futures/Future-inl.h b/folly/futures/Future-inl.h
index b3ca83e64c81346429fa7bf3b8b37489c04a31f9..33b758ea2db126692601b62850a9a5ca9a2a035d 100644 (file)
--- a/folly/futures/Future-inl.h
+++ b/folly/futures/Future-inl.h
@@ -1001,11 +1001,27 @@ inline void Future<void>::getVia(DrivableExecutor* e) {
   waitVia(e).value();
 }
 
+namespace detail {
+  template <class T>
+  struct TryEquals {
+    static bool equals(const Try<T>& t1, const Try<T>& t2) {
+      return t1.value() == t2.value();
+    }
+  };
+
+  template <>
+  struct TryEquals<void> {
+    static bool equals(const Try<void>& t1, const Try<void>& t2) {
+      return true;
+    }
+  };
+}
+
 template <class T>
 Future<bool> Future<T>::willEqual(Future<T>& f) {
   return collectAll(*this, f).then([](const std::tuple<Try<T>, Try<T>>& t) {
     if (std::get<0>(t).hasValue() && std::get<1>(t).hasValue()) {
-      return std::get<0>(t).value() == std::get<1>(t).value();
+      return detail::TryEquals<T>::equals(std::get<0>(t), std::get<1>(t));
     } else {
       return false;
       }
@@ -1059,6 +1075,14 @@ namespace futures {
   }
 }
 
+// Instantiate the most common Future types to save compile time
+extern template class Future<void>;
+extern template class Future<bool>;
+extern template class Future<int>;
+extern template class Future<int64_t>;
+extern template class Future<std::string>;
+extern template class Future<double>;
+
 } // namespace folly
 
 // I haven't included a Future<T&> specialization because I don't forsee us

diff --git a/folly/futures/Future.cpp b/folly/futures/Future.cpp
index c914ccd376a990ae8094d8ac10ca8a56a6cd2e5f..0f6dc3d15128a1c1e56fc68f146900afc0e5347b 100644 (file)
--- a/folly/futures/Future.cpp
+++ b/folly/futures/Future.cpp
@@ -17,6 +17,18 @@
 #include <folly/futures/detail/ThreadWheelTimekeeper.h>
 #include <folly/Likely.h>
 
+namespace folly {
+
+// Instantiate the most common Future types to save compile time
+template class Future<void>;
+template class Future<bool>;
+template class Future<int>;
+template class Future<int64_t>;
+template class Future<std::string>;
+template class Future<double>;
+
+}
+
 namespace folly { namespace futures {
 
 Future<void> sleep(Duration dur, Timekeeper* tk) {

diff --git a/folly/futures/Future.h b/folly/futures/Future.h
index 924c38052b26a22db3dc58f8caa0d0bc47776d42..b26369cee455bc561217e7484d1049fa436c82d4 100644 (file)
--- a/folly/futures/Future.h
+++ b/folly/futures/Future.h
@@ -282,19 +282,19 @@ class Future {
   /// by then), and it is active (active by default).
   ///
   /// Inactive Futures will activate upon destruction.
-  Future<T>& activate() & {
+  Future<T>& activate() & DEPRECATED {
     core_->activate();
     return *this;
   }
-  Future<T>& deactivate() & {
+  Future<T>& deactivate() & DEPRECATED {
     core_->deactivate();
     return *this;
   }
-  Future<T> activate() && {
+  Future<T> activate() && DEPRECATED {
     core_->activate();
     return std::move(*this);
   }
-  Future<T> deactivate() && {
+  Future<T> deactivate() && DEPRECATED {
     core_->deactivate();
     return std::move(*this);
   }

diff --git a/folly/futures/detail/Core.h b/folly/futures/detail/Core.h
index 85f7b6cade44d3b18a6af753a818b1b3af482f7a..7e23dd7c665f13b14a341ca4d1faeb9ec80c9752 100644 (file)
--- a/folly/futures/detail/Core.h
+++ b/folly/futures/detail/Core.h
@@ -198,7 +198,7 @@ class Core {
 
   /// Called by a destructing Future (in the Future thread, by definition)
   void detachFuture() {
-    activateNoDeprecatedWarning();
+    activate();
     detachOne();
   }
 
@@ -213,13 +213,14 @@ class Core {
   }
 
   /// May call from any thread
-  void deactivate() DEPRECATED {
+  void deactivate() {
     active_ = false;
   }
 
   /// May call from any thread
-  void activate() DEPRECATED {
-    activateNoDeprecatedWarning();
+  void activate() {
+    active_ = true;
+    maybeCallback();
   }
 
   /// May call from any thread
@@ -258,11 +259,6 @@ class Core {
   }
 
  protected:
-  void activateNoDeprecatedWarning() {
-    active_ = true;
-    maybeCallback();
-  }
-
   void maybeCallback() {
     FSM_START(fsm_)
       case State::Armed: