grpc 1.25.0 → 1.26.0.pre1

data/src/core/lib/iomgr/executor.cc

@@ -77,28 +77,13 @@ void resolver_enqueue_long(grpc_closure* closure, grpc_error* error) {
       closure, error, false /* is_short */);
 }
 
-const grpc_closure_scheduler_vtable
-    vtables_[static_cast<size_t>(ExecutorType::NUM_EXECUTORS)]
-            [static_cast<size_t>(ExecutorJobType::NUM_JOB_TYPES)] = {
-                {{&default_enqueue_short, &default_enqueue_short,
-                  "def-ex-short"},
-                 {&default_enqueue_long, &default_enqueue_long, "def-ex-long"}},
-                {{&resolver_enqueue_short, &resolver_enqueue_short,
-                  "res-ex-short"},
-                 {&resolver_enqueue_long, &resolver_enqueue_long,
-                  "res-ex-long"}}};
-
-grpc_closure_scheduler
-    schedulers_[static_cast<size_t>(ExecutorType::NUM_EXECUTORS)]
-               [static_cast<size_t>(ExecutorJobType::NUM_JOB_TYPES)] = {
-                   {{&vtables_[static_cast<size_t>(ExecutorType::DEFAULT)]
-                              [static_cast<size_t>(ExecutorJobType::SHORT)]},
-                    {&vtables_[static_cast<size_t>(ExecutorType::DEFAULT)]
-                              [static_cast<size_t>(ExecutorJobType::LONG)]}},
-                   {{&vtables_[static_cast<size_t>(ExecutorType::RESOLVER)]
-                              [static_cast<size_t>(ExecutorJobType::SHORT)]},
-                    {&vtables_[static_cast<size_t>(ExecutorType::RESOLVER)]
-                              [static_cast<size_t>(ExecutorJobType::LONG)]}}};
+using EnqueueFunc = void (*)(grpc_closure* closure, grpc_error* error);
+
+const EnqueueFunc
+    executor_enqueue_fns_[static_cast<size_t>(ExecutorType::NUM_EXECUTORS)]
+                         [static_cast<size_t>(ExecutorJobType::NUM_JOB_TYPES)] =
+                             {{default_enqueue_short, default_enqueue_long},
+                              {resolver_enqueue_short, resolver_enqueue_long}};
 
 }  // namespace
 
@@ -408,9 +393,9 @@ void Executor::InitAll() {
   }
 
   executors[static_cast<size_t>(ExecutorType::DEFAULT)] =
-      grpc_core::New<Executor>("default-executor");
+      new Executor("default-executor");
   executors[static_cast<size_t>(ExecutorType::RESOLVER)] =
-      grpc_core::New<Executor>("resolver-executor");
+      new Executor("resolver-executor");
 
   executors[static_cast<size_t>(ExecutorType::DEFAULT)]->Init();
   executors[static_cast<size_t>(ExecutorType::RESOLVER)]->Init();
@@ -418,14 +403,10 @@ void Executor::InitAll() {
   EXECUTOR_TRACE0("Executor::InitAll() done");
 }
 
-grpc_closure_scheduler* Executor::Scheduler(ExecutorType executor_type,
-                                            ExecutorJobType job_type) {
-  return &schedulers_[static_cast<size_t>(executor_type)]
-                     [static_cast<size_t>(job_type)];
-}
-
-grpc_closure_scheduler* Executor::Scheduler(ExecutorJobType job_type) {
-  return Executor::Scheduler(ExecutorType::DEFAULT, job_type);
+void Executor::Run(grpc_closure* closure, grpc_error* error,
+                   ExecutorType executor_type, ExecutorJobType job_type) {
+  executor_enqueue_fns_[static_cast<size_t>(executor_type)]
+                       [static_cast<size_t>(job_type)](closure, error);
 }
 
 void Executor::ShutdownAll() {
@@ -444,7 +425,7 @@ void Executor::ShutdownAll() {
   // Delete the executor objects.
   //
   // NOTE: It is important to call Shutdown() on all executors first before
-  // calling Delete() because it is possible for one executor (that is not
+  // calling delete  because it is possible for one executor (that is not
   // shutdown yet) to call Enqueue() on a different executor which is already
   // shutdown. This is legal and in such cases, the Enqueue() operation
   // effectively "fails" and enqueues that closure on the calling thread's
@@ -453,10 +434,8 @@ void Executor::ShutdownAll() {
   // By ensuring that all executors are shutdown first, we are also ensuring
   // that no thread is active across all executors.
 
-  grpc_core::Delete<Executor>(
-      executors[static_cast<size_t>(ExecutorType::DEFAULT)]);
-  grpc_core::Delete<Executor>(
-      executors[static_cast<size_t>(ExecutorType::RESOLVER)]);
+  delete executors[static_cast<size_t>(ExecutorType::DEFAULT)];
+  delete executors[static_cast<size_t>(ExecutorType::RESOLVER)];
   executors[static_cast<size_t>(ExecutorType::DEFAULT)] = nullptr;
   executors[static_cast<size_t>(ExecutorType::RESOLVER)] = nullptr;
 

data/src/core/lib/iomgr/executor.h

@@ -83,6 +83,10 @@ class Executor {
   // Initialize ALL the executors
   static void InitAll();
 
+  static void Run(grpc_closure* closure, grpc_error* error,
+                  ExecutorType executor_type = ExecutorType::DEFAULT,
+                  ExecutorJobType job_type = ExecutorJobType::SHORT);
+
   // Shutdown ALL the executors
   static void ShutdownAll();
 
@@ -92,13 +96,6 @@ class Executor {
   // Set the threading mode for ALL the executors
   static void SetThreadingDefault(bool enable);
 
-  // Get the DEFAULT executor scheduler for the given job_type
-  static grpc_closure_scheduler* Scheduler(ExecutorJobType job_type);
-
-  // Get the executor scheduler for a given executor_type and a job_type
-  static grpc_closure_scheduler* Scheduler(ExecutorType executor_type,
-                                           ExecutorJobType job_type);
-
   // Return if a given executor is running in threaded mode (i.e if
   // SetThreading(true) was called previously on that executor)
   static bool IsThreaded(ExecutorType executor_type);

data/src/core/lib/iomgr/executor/threadpool.cc

@@ -54,11 +54,11 @@ void ThreadPool::SharedThreadPoolConstructor() {
   // Create at least 1 worker thread.
   if (num_threads_ <= 0) num_threads_ = 1;
 
-  queue_ = New<InfLenFIFOQueue>();
+  queue_ = new InfLenFIFOQueue();
   threads_ = static_cast<ThreadPoolWorker**>(
       gpr_zalloc(num_threads_ * sizeof(ThreadPoolWorker*)));
   for (int i = 0; i < num_threads_; ++i) {
-    threads_[i] = New<ThreadPoolWorker>(thd_name_, queue_, thread_options_, i);
+    threads_[i] = new ThreadPoolWorker(thd_name_, queue_, thread_options_, i);
     threads_[i]->Start();
   }
 }
@@ -114,10 +114,10 @@ ThreadPool::~ThreadPool() {
   }
 
   for (int i = 0; i < num_threads_; ++i) {
-    Delete(threads_[i]);
+    delete threads_[i];
   }
   gpr_free(threads_);
-  Delete(queue_);
+  delete queue_;
 }
 
 void ThreadPool::Add(grpc_experimental_completion_queue_functor* closure) {

data/src/core/lib/iomgr/iomgr_custom.cc

@@ -45,7 +45,7 @@ static bool iomgr_platform_is_any_background_poller_thread(void) {
   return false;
 }
 static bool iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error* error) {
+    grpc_closure* /*closure*/, grpc_error* /*error*/) {
   return false;
 }
 

data/src/core/lib/iomgr/lockfree_event.cc

@@ -23,6 +23,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 
 extern grpc_core::DebugOnlyTraceFlag grpc_polling_trace;
 
@@ -124,7 +125,7 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
            closure when transitioning out of CLOSURE_NO_READY state (i.e there
            is no other code that needs to 'happen-after' this) */
         if (gpr_atm_no_barrier_cas(&state_, kClosureReady, kClosureNotReady)) {
-          GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
+          ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
           return; /* Successful. Return */
         }
 
@@ -137,9 +138,9 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
            schedule the closure with the shutdown error */
         if ((curr & kShutdownBit) > 0) {
           grpc_error* shutdown_err = (grpc_error*)(curr & ~kShutdownBit);
-          GRPC_CLOSURE_SCHED(closure,
-                             GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                                 "FD Shutdown", &shutdown_err, 1));
+          ExecCtx::Run(DEBUG_LOCATION, closure,
+                       GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                           "FD Shutdown", &shutdown_err, 1));
           return;
         }
 
@@ -189,9 +190,9 @@ bool LockfreeEvent::SetShutdown(grpc_error* shutdown_err) {
            happens-after on that edge), and a release to pair with anything
            loading the shutdown state. */
         if (gpr_atm_full_cas(&state_, curr, new_state)) {
-          GRPC_CLOSURE_SCHED((grpc_closure*)curr,
-                             GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                                 "FD Shutdown", &shutdown_err, 1));
+          ExecCtx::Run(DEBUG_LOCATION, (grpc_closure*)curr,
+                       GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                           "FD Shutdown", &shutdown_err, 1));
           return true;
         }
 
@@ -239,7 +240,7 @@ void LockfreeEvent::SetReady() {
            spurious set_ready; release pairs with this or the acquire in
            notify_on (or set_shutdown) */
         else if (gpr_atm_full_cas(&state_, curr, kClosureNotReady)) {
-          GRPC_CLOSURE_SCHED((grpc_closure*)curr, GRPC_ERROR_NONE);
+          ExecCtx::Run(DEBUG_LOCATION, (grpc_closure*)curr, GRPC_ERROR_NONE);
           return;
         }
         /* else the state changed again (only possible by either a racing

data/src/core/lib/iomgr/logical_thread.cc

@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/logical_thread.h"
+
+namespace grpc_core {
+
+DebugOnlyTraceFlag grpc_logical_thread_trace(false, "logical_thread");
+
+struct CallbackWrapper {
+  CallbackWrapper(std::function<void()> cb, const grpc_core::DebugLocation& loc)
+      : callback(std::move(cb)), location(loc) {}
+
+  MultiProducerSingleConsumerQueue::Node mpscq_node;
+  const std::function<void()> callback;
+  const DebugLocation location;
+};
+
+void LogicalThread::Run(std::function<void()> callback,
+                        const grpc_core::DebugLocation& location) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_logical_thread_trace)) {
+    gpr_log(GPR_INFO, "LogicalThread::Run() %p Scheduling callback [%s:%d]",
+            this, location.file(), location.line());
+  }
+  const size_t prev_size = size_.FetchAdd(1);
+  if (prev_size == 0) {
+    // There is no other closure executing right now on this logical thread.
+    // Execute this closure immediately.
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_logical_thread_trace)) {
+      gpr_log(GPR_INFO, "  Executing immediately");
+    }
+    callback();
+    // Loan this thread to the logical thread and drain the queue.
+    DrainQueue();
+  } else {
+    CallbackWrapper* cb_wrapper =
+        new CallbackWrapper(std::move(callback), location);
+    // There already are closures executing on this logical thread. Simply add
+    // this closure to the queue.
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_logical_thread_trace)) {
+      gpr_log(GPR_INFO, "  Scheduling on queue : item %p", cb_wrapper);
+    }
+    queue_.Push(&cb_wrapper->mpscq_node);
+  }
+}
+
+// The thread that calls this loans itself to the logical thread so as to
+// execute all the scheduled callback. This is called from within
+// LogicalThread::Run() after executing a callback immediately, and hence size_
+// is atleast 1.
+void LogicalThread::DrainQueue() {
+  while (true) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_logical_thread_trace)) {
+      gpr_log(GPR_INFO, "LogicalThread::DrainQueue() %p", this);
+    }
+    size_t prev_size = size_.FetchSub(1);
+    // prev_size should be atleast 1 since
+    GPR_DEBUG_ASSERT(prev_size >= 1);
+    if (prev_size == 1) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_logical_thread_trace)) {
+        gpr_log(GPR_INFO, "  Queue Drained");
+      }
+      break;
+    }
+    // There is atleast one callback on the queue. Pop the callback from the
+    // queue and execute it.
+    CallbackWrapper* cb_wrapper = nullptr;
+    bool empty_unused;
+    while ((cb_wrapper = reinterpret_cast<CallbackWrapper*>(
+                queue_.PopAndCheckEnd(&empty_unused))) == nullptr) {
+      // This can happen either due to a race condition within the mpscq
+      // implementation or because of a race with Run()
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_logical_thread_trace)) {
+        gpr_log(GPR_INFO, "  Queue returned nullptr, trying again");
+      }
+    }
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_logical_thread_trace)) {
+      gpr_log(GPR_INFO, "  Running item %p : callback scheduled at [%s:%d]",
+              cb_wrapper, cb_wrapper->location.file(),
+              cb_wrapper->location.line());
+    }
+    cb_wrapper->callback();
+    delete cb_wrapper;
+  }
+}
+}  // namespace grpc_core

data/src/core/lib/iomgr/logical_thread.h

@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/atomic.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/mpscq.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+
+#ifndef GRPC_CORE_LIB_IOMGR_LOGICAL_THREAD_H
+#define GRPC_CORE_LIB_IOMGR_LOGICAL_THREAD_H
+
+namespace grpc_core {
+extern DebugOnlyTraceFlag grpc_logical_thread_trace;
+
+// LogicalThread is a mechanism to schedule callbacks in a synchronized manner.
+// All callbacks scheduled on a LogicalThread instance will be executed serially
+// in a borrowed thread. The API provides a FIFO guarantee to the execution of
+// callbacks scheduled on the thread.
+class LogicalThread : public RefCounted<LogicalThread> {
+ public:
+  void Run(std::function<void()> callback,
+           const grpc_core::DebugLocation& location);
+
+ private:
+  void DrainQueue();
+
+  Atomic<size_t> size_{0};
+  MultiProducerSingleConsumerQueue queue_;
+};
+} /* namespace grpc_core */
+
+#endif /* GRPC_CORE_LIB_IOMGR_LOGICAL_THREAD_H */

data/src/core/lib/iomgr/pollset_custom.cc

@@ -53,9 +53,9 @@ static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   *mu = &pollset->mu;
 }
 
-static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
+static void pollset_shutdown(grpc_pollset* /*pollset*/, grpc_closure* closure) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
-  GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
 }
 
 static void pollset_destroy(grpc_pollset* pollset) {
@@ -64,7 +64,7 @@ static void pollset_destroy(grpc_pollset* pollset) {
 }
 
 static grpc_error* pollset_work(grpc_pollset* pollset,
-                                grpc_pollset_worker** worker_hdl,
+                                grpc_pollset_worker** /*worker_hdl*/,
                                 grpc_millis deadline) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   gpr_mu_unlock(&pollset->mu);
@@ -87,8 +87,8 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* pollset_kick(grpc_pollset* pollset,
-                                grpc_pollset_worker* specific_worker) {
+static grpc_error* pollset_kick(grpc_pollset* /*pollset*/,
+                                grpc_pollset_worker* /*specific_worker*/) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   poller_vtable->kick();
   return GRPC_ERROR_NONE;

data/src/core/lib/iomgr/pollset_set_custom.cc

@@ -26,19 +26,19 @@ grpc_pollset_set* pollset_set_create(void) {
   return (grpc_pollset_set*)((intptr_t)0xdeafbeef);
 }
 
-void pollset_set_destroy(grpc_pollset_set* pollset_set) {}
+void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}
 
-void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
-                             grpc_pollset* pollset) {}
+void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/,
+                             grpc_pollset* /*pollset*/) {}
 
-void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
-                             grpc_pollset* pollset) {}
+void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/,
+                             grpc_pollset* /*pollset*/) {}
 
-void pollset_set_add_pollset_set(grpc_pollset_set* bag,
-                                 grpc_pollset_set* item) {}
+void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
+                                 grpc_pollset_set* /*item*/) {}
 
-void pollset_set_del_pollset_set(grpc_pollset_set* bag,
-                                 grpc_pollset_set* item) {}
+void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
+                                 grpc_pollset_set* /*item*/) {}
 
 static grpc_pollset_set_vtable vtable = {
     pollset_set_create,          pollset_set_destroy,

data/src/core/lib/iomgr/pollset_windows.cc

@@ -98,7 +98,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   pollset->shutting_down = 1;
   grpc_pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
   if (!pollset->is_iocp_worker) {
-    GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
   } else {
     pollset->on_shutdown = closure;
   }
@@ -146,7 +146,8 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
       }
 
       if (pollset->shutting_down && pollset->on_shutdown != NULL) {
-        GRPC_CLOSURE_SCHED(pollset->on_shutdown, GRPC_ERROR_NONE);
+        grpc_core::ExecCtx::Run(DEBUG_LOCATION, pollset->on_shutdown,
+                                GRPC_ERROR_NONE);
         pollset->on_shutdown = NULL;
       }
       goto done;
@@ -184,19 +185,23 @@ done:
 
 static grpc_error* pollset_kick(grpc_pollset* p,
                                 grpc_pollset_worker* specific_worker) {
+  bool should_kick_global = false;
   if (specific_worker != NULL) {
     if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
+      should_kick_global = true;
       for (specific_worker =
                p->root_worker.links[GRPC_POLLSET_WORKER_LINK_POLLSET].next;
            specific_worker != &p->root_worker;
            specific_worker =
                specific_worker->links[GRPC_POLLSET_WORKER_LINK_POLLSET].next) {
         specific_worker->kicked = 1;
+        should_kick_global = false;
         gpr_cv_signal(&specific_worker->cv);
       }
       p->kicked_without_pollers = 1;
       if (p->is_iocp_worker) {
         grpc_iocp_kick();
+        should_kick_global = false;
       }
     } else {
       if (p->is_iocp_worker && g_active_poller == specific_worker) {
@@ -215,6 +220,15 @@ static grpc_error* pollset_kick(grpc_pollset* p,
       grpc_iocp_kick();
     } else {
       p->kicked_without_pollers = 1;
+      should_kick_global = true;
+    }
+  }
+  if (should_kick_global && g_active_poller == NULL) {
+    grpc_pollset_worker* next_global_worker = pop_front_worker(
+        &g_global_root_worker, GRPC_POLLSET_WORKER_LINK_GLOBAL);
+    if (next_global_worker != NULL) {
+      next_global_worker->kicked = 1;
+      gpr_cv_signal(&next_global_worker->cv);
     }
   }
   return GRPC_ERROR_NONE;