Add Unsafe names for set and get executor calls

Summary:
To encourage migration to safer executors, add transitional *Unsafe names for the old, mutable, global executors. This is consistent with the use of *Unsafe elsewhere in the async framework.

(Note: this ignores all push blocking failures!)

Reviewed By: yfeldblum

Differential Revision: D26418111

fbshipit-source-id: 414ee238ed4ae43619ce8d671fa5725f0679f67e

folly/executors/Async.h

@@ -22,7 +22,8 @@ namespace folly {
 
 template <class F>
 auto async(F&& fn) {
-  return folly::via<F>(getCPUExecutor().get(), std::forward<F>(fn));
+  return folly::via<F>(
+      getUnsafeMutableGlobalCPUExecutor().get(), std::forward<F>(fn));
 }
 
 } // namespace folly

folly/executors/GlobalExecutor.cpp

@@ -159,37 +159,57 @@ Executor::KeepAlive<IOExecutor> getGlobalIOExecutor() {
   return folly::getKeepAliveToken(executorPtrPtr->get());
 }
 
-std::shared_ptr<Executor> getCPUExecutor() {
+std::shared_ptr<Executor> getUnsafeMutableGlobalCPUExecutor() {
   auto& singleton = gGlobalCPUExecutor.get();
   auto executor = singleton.get();
   async_tracing::logGetGlobalCPUExecutor(executor.get());
   return executor;
 }
 
-void setCPUExecutorToGlobalCPUExecutor() {
+std::shared_ptr<Executor> getCPUExecutor() {
+  return getUnsafeMutableGlobalCPUExecutor();
+}
+
+void setUnsafeMutableGlobalCPUExecutorToGlobalCPUExecutor() {
   async_tracing::logSetGlobalCPUExecutorToImmutable();
   gGlobalCPUExecutor.get().setFromImmutable();
 }
 
-void setCPUExecutor(std::weak_ptr<Executor> executor) {
+void setCPUExecutorToGlobalCPUExecutor() {
+  setUnsafeMutableGlobalCPUExecutorToGlobalCPUExecutor();
+}
+
+void setUnsafeMutableGlobalCPUExecutor(std::weak_ptr<Executor> executor) {
   async_tracing::logSetGlobalCPUExecutor(executor.lock().get());
   gGlobalCPUExecutor.get().set(std::move(executor));
 }
 
-std::shared_ptr<IOExecutor> getIOExecutor() {
+void setCPUExecutor(std::weak_ptr<Executor> executor) {
+  setUnsafeMutableGlobalCPUExecutor(std::move(executor));
+}
+
+std::shared_ptr<IOExecutor> getUnsafeMutableGlobalIOExecutor() {
   auto& singleton = gGlobalIOExecutor.get();
   auto executor = singleton.get();
   async_tracing::logGetGlobalIOExecutor(executor.get());
   return executor;
 }
 
-void setIOExecutor(std::weak_ptr<IOExecutor> executor) {
+std::shared_ptr<IOExecutor> getIOExecutor() {
+  return getUnsafeMutableGlobalIOExecutor();
+}
+
+void setUnsafeMutableGlobalIOExecutor(std::weak_ptr<IOExecutor> executor) {
   async_tracing::logSetGlobalIOExecutor(executor.lock().get());
   gGlobalIOExecutor.get().set(std::move(executor));
 }
 
-EventBase* getEventBase() {
-  auto executor = getIOExecutor();
+void setIOExecutor(std::weak_ptr<IOExecutor> executor) {
+  setUnsafeMutableGlobalIOExecutor(std::move(executor));
+}
+
+EventBase* getUnsafeMutableGlobalEventBase() {
+  auto executor = getUnsafeMutableGlobalIOExecutor();
   if (FOLLY_LIKELY(!!executor)) {
     return executor->getEventBase();
   }
@@ -197,4 +217,8 @@ EventBase* getEventBase() {
   return nullptr;
 }
 
+EventBase* getEventBase() {
+  return getUnsafeMutableGlobalEventBase();
+}
+
 } // namespace folly

folly/executors/GlobalExecutor.h

@@ -50,19 +50,34 @@ folly::Executor::KeepAlive<IOExecutor> getGlobalIOExecutor();
  *
  * Can return nullptr on shutdown.
  */
-std::shared_ptr<folly::Executor> getCPUExecutor();
+[[deprecated(
+    "getCPUExecutor is deprecated. "
+    "To use the global mutable executor use getUnsafeMutableGlobalCPUExecutor. "
+    "For a better solution use getGlobalCPUExecutor.")]] std::
+    shared_ptr<folly::Executor>
+    getCPUExecutor();
+std::shared_ptr<folly::Executor> getUnsafeMutableGlobalCPUExecutor();
 
 /**
  * Set an Executor to be the global Executor which will be returned by
  * subsequent calls to getCPUExecutor().
  */
-void setCPUExecutor(std::weak_ptr<folly::Executor> executor);
+[[deprecated(
+    "setCPUExecutor is deprecated. "
+    "To use the global mutable executor use setUnsafeMutableGlobalCPUExecutor. "
+    "For a better solution use getGlobalCPUExecutor and avoid calling set.")]] void
+setCPUExecutor(std::weak_ptr<folly::Executor> executor);
+void setUnsafeMutableGlobalCPUExecutor(std::weak_ptr<folly::Executor> executor);
 
 /**
  * Set the CPU executor to the immutable default returned by
  * getGlobalCPUExecutor.
  */
-void setCPUExecutorToGlobalCPUExecutor();
+[[deprecated(
+    "setCPUExecutorToGlobalCPUExecutor is deprecated. "
+    "Switch to setUnsafeMutableGlobalCPUExecutorToGlobalCPUExecutor. ")]] void
+setCPUExecutorToGlobalCPUExecutor();
+void setUnsafeMutableGlobalCPUExecutorToGlobalCPUExecutor();
 
 /**
  * Retrieve the global IOExecutor. If there is none, a default
@@ -73,13 +88,24 @@ void setCPUExecutorToGlobalCPUExecutor();
  *
  * Can return nullptr on shutdown.
  */
-std::shared_ptr<IOExecutor> getIOExecutor();
+[[deprecated(
+    "getIOExecutor is deprecated. "
+    "To use the global mutable executor use getUnsafeMutableGlobalIOExecutor. "
+    "For a better solution use getGlobalIOExecutor.")]] std::
+    shared_ptr<IOExecutor>
+    getIOExecutor();
+std::shared_ptr<IOExecutor> getUnsafeMutableGlobalIOExecutor();
 
 /**
  * Set an IOExecutor to be the global IOExecutor which will be returned by
  * subsequent calls to getIOExecutor().
  */
-void setIOExecutor(std::weak_ptr<IOExecutor> executor);
+[[deprecated(
+    "setIOExecutor is deprecated. "
+    "To use the global mutable executor use setUnsafeMutableGlobalIOExecutor. "
+    "For a better solution use getGlobalIOExecutor and avoid calling set.")]] void
+setIOExecutor(std::weak_ptr<IOExecutor> executor);
+void setUnsafeMutableGlobalIOExecutor(std::weak_ptr<IOExecutor> executor);
 
 /**
  * Retrieve an event base from the global IOExecutor
@@ -87,6 +113,12 @@ void setIOExecutor(std::weak_ptr<IOExecutor> executor);
  * NOTE: This is not shutdown-safe, the returned pointer may be
  * invalid during shutdown.
  */
-folly::EventBase* getEventBase();
+[[deprecated(
+    "getEventBase is deprecated. "
+    "To use the global mutable executor use getUnsafeMutableGlobalEventBase. "
+    "For a better solution use getGlobalIOExecutor and request the EventBase "
+    "from there.")]] folly::EventBase*
+getEventBase();
+folly::EventBase* getUnsafeMutableGlobalEventBase();
 
 } // namespace folly

folly/executors/SerialExecutor.h

@@ -58,7 +58,8 @@ class SerialExecutor : public SequencedExecutor {
   SerialExecutor& operator=(SerialExecutor&&) = delete;
 
   static KeepAlive<SerialExecutor> create(
-      KeepAlive<Executor> parent = getKeepAliveToken(getCPUExecutor().get()));
+      KeepAlive<Executor> parent =
+          getKeepAliveToken(getUnsafeMutableGlobalCPUExecutor().get()));
 
   class Deleter {
    public:

folly/executors/test/AsyncTest.cpp

@@ -24,6 +24,8 @@
 using namespace folly;
 
 TEST(AsyncFunc, manual_executor) {
+  FOLLY_PUSH_WARNING
+  FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations")
   auto x = std::make_shared<ManualExecutor>();
   auto oldX = getCPUExecutor();
   setCPUExecutor(x);
@@ -32,6 +34,7 @@ TEST(AsyncFunc, manual_executor) {
   x->run();
   EXPECT_EQ(42, f.value());
   setCPUExecutor(oldX);
+  FOLLY_POP_WARNING
 }
 
 TEST(AsyncFunc, value_lambda) {

folly/executors/test/GlobalExecutorAssignmentTest.cpp

@@ -34,7 +34,8 @@ TEST(GlobalExecutorAssignmentTest, GlobalCPUExecutorAsImmutable) {
     b.post();
   };
 
-  {
+  FOLLY_PUSH_WARNING
+  FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") {
     auto inlineExec = getCPUExecutor();
     EXPECT_EQ(
         dynamic_cast<folly::CPUThreadPoolExecutor*>(inlineExec.get()), nullptr);
@@ -50,4 +51,5 @@ TEST(GlobalExecutorAssignmentTest, GlobalCPUExecutorAsImmutable) {
     b.wait();
     EXPECT_EQ(1, count);
   }
+  FOLLY_POP_WARNING
 }

folly/executors/test/GlobalExecutorTest.cpp

@@ -67,6 +67,8 @@ TEST(GlobalExecutorTest, GlobalCPUExecutor) {
   auto f = [&]() {};
 
   // Don't explode, we should create the default global CPUExecutor lazily here.
+  FOLLY_PUSH_WARNING
+  FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations")
   getCPUExecutor()->add(f);
 
   {
@@ -80,6 +82,7 @@ TEST(GlobalExecutorTest, GlobalCPUExecutor) {
   // Don't explode, we should restore the default global CPUExecutor because our
   // weak reference to dummy has expired
   getCPUExecutor()->add(f);
+  FOLLY_POP_WARNING
 }
 
 TEST(GlobalExecutorTest, GlobalIOExecutor) {
@@ -92,6 +95,8 @@ TEST(GlobalExecutorTest, GlobalIOExecutor) {
 
   auto f = []() {};
 
+  FOLLY_PUSH_WARNING
+  FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations")
   // Don't explode, we should create the default global IOExecutor lazily here.
   getIOExecutor()->add(f);
 
@@ -106,4 +111,5 @@ TEST(GlobalExecutorTest, GlobalIOExecutor) {
   // Don't explode, we should restore the default global IOExecutor because our
   // weak reference to dummy has expired
   getIOExecutor()->add(f);
+  FOLLY_POP_WARNING
 }

folly/experimental/io/SimpleAsyncIO.h

@@ -74,7 +74,8 @@ class SimpleAsyncIO : public EventHandler {
   struct Config {
     Config()
         : maxRequests_(1000),
-          completionExecutor_(getKeepAliveToken(getCPUExecutor().get())),
+          completionExecutor_(
+              getKeepAliveToken(getUnsafeMutableGlobalCPUExecutor().get())),
           mode_(AIO),
           evb_(nullptr) {}
     Config& setMaxRequests(size_t maxRequests) {