grpc 1.18.0 → 1.22.0

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

@@ -24,16 +24,20 @@
 #include <poll.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
-extern grpc_core::TraceFlag grpc_fd_trace;      /* Disabled by default */
-extern grpc_core::TraceFlag grpc_polling_trace; /* Disabled by default */
+GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_poll_strategy);
+
+extern grpc_core::DebugOnlyTraceFlag grpc_fd_trace; /* Disabled by default */
+extern grpc_core::DebugOnlyTraceFlag
+    grpc_polling_trace; /* Disabled by default */
 
 #define GRPC_FD_TRACE(format, ...)                        \
-  if (grpc_fd_trace.enabled()) {                          \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_fd_trace)) {           \
     gpr_log(GPR_INFO, "(fd-trace) " format, __VA_ARGS__); \
   }
 
@@ -80,8 +84,11 @@ typedef struct grpc_event_engine_vtable {
   void (*pollset_set_add_fd)(grpc_pollset_set* pollset_set, grpc_fd* fd);
   void (*pollset_set_del_fd)(grpc_pollset_set* pollset_set, grpc_fd* fd);
 
+  bool (*is_any_background_poller_thread)(void);
   void (*shutdown_background_closure)(void);
   void (*shutdown_engine)(void);
+  bool (*add_closure_to_background_poller)(grpc_closure* closure,
+                                           grpc_error* error);
 } grpc_event_engine_vtable;
 
 /* register a new event engine factory */
@@ -181,6 +188,15 @@ void grpc_pollset_add_fd(grpc_pollset* pollset, struct grpc_fd* fd);
 void grpc_pollset_set_add_fd(grpc_pollset_set* pollset_set, grpc_fd* fd);
 void grpc_pollset_set_del_fd(grpc_pollset_set* pollset_set, grpc_fd* fd);
 
+/* Returns true if the caller is a worker thread for any background poller. */
+bool grpc_is_any_background_poller_thread();
+
+/* Returns true if the closure is registered into the background poller. Note
+ * that the closure may or may not run yet when this function returns, and the
+ * closure should not be blocking or long-running. */
+bool grpc_add_closure_to_background_poller(grpc_closure* closure,
+                                           grpc_error* error);
+
 /* Shut down all the closures registered in the background poller. */
 void grpc_shutdown_background_closure();
 

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

@@ -24,7 +24,7 @@
 
 #include "src/core/lib/debug/trace.h"
 
-grpc_core::TraceFlag grpc_polling_trace(false,
-                                        "polling"); /* Disabled by default */
+grpc_core::DebugOnlyTraceFlag grpc_polling_trace(
+    false, "polling"); /* Disabled by default */
 
 #endif  // GRPC_WINSOCK_SOCKET

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

@@ -115,6 +115,7 @@ grpc_closure_scheduler* grpc_schedule_on_exec_ctx = &exec_ctx_scheduler;
 
 namespace grpc_core {
 GPR_TLS_CLASS_DEF(ExecCtx::exec_ctx_);
+GPR_TLS_CLASS_DEF(ApplicationCallbackExecCtx::callback_exec_ctx_);
 
 // WARNING: for testing purposes only!
 void ExecCtx::TestOnlyGlobalInit(gpr_timespec new_val) {

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
@@ -34,9 +35,8 @@ typedef int64_t grpc_millis;
 #define GRPC_MILLIS_INF_FUTURE INT64_MAX
 #define GRPC_MILLIS_INF_PAST INT64_MIN
 
-/** A workqueue represents a list of work to be executed asynchronously.
-    Forward declared here to avoid a circular dependency with workqueue.h. */
-typedef struct grpc_workqueue grpc_workqueue;
+/** A combiner represents a list of work to be executed later.
+    Forward declared here to avoid a circular dependency with combiner.h. */
 typedef struct grpc_combiner grpc_combiner;
 
 /* This exec_ctx is ready to return: either pre-populated, or cached as soon as
@@ -49,6 +49,10 @@ typedef struct grpc_combiner grpc_combiner;
    be counted by fork handlers */
 #define GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD 4
 
+/* This application callback exec ctx was initialized by an internal thread, and
+   should not be counted by fork handlers */
+#define GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD 1
+
 extern grpc_closure_scheduler* grpc_schedule_on_exec_ctx;
 
 gpr_timespec grpc_millis_to_timespec(grpc_millis millis, gpr_clock_type clock);
@@ -58,8 +62,8 @@ grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec timespec);
 namespace grpc_core {
 /** Execution context.
  *  A bag of data that collects information along a callstack.
- *  It is created on the stack at public API entry points, and stored internally
- *  as a thread-local variable.
+ *  It is created on the stack at core entry points (public API or iomgr), and
+ *  stored internally as a thread-local variable.
  *
  *  Generally, to create an exec_ctx instance, add the following line at the top
  *  of the public API entry point or at the start of a thread's work function :
@@ -70,7 +74,7 @@ namespace grpc_core {
  *  grpc_core::ExecCtx::Get()
  *
  *  Specific responsibilities (this may grow in the future):
- *  - track a list of work that needs to be delayed until the top of the
+ *  - track a list of core work that needs to be delayed until the base of the
  *    call stack (this provides a convenient mechanism to run callbacks
  *    without worrying about locking issues)
  *  - provide a decision maker (via IsReadyToFinish) that provides a
@@ -80,10 +84,19 @@ namespace grpc_core {
  *  CONVENTIONS:
  *  - Instance of this must ALWAYS be constructed on the stack, never
  *    heap allocated.
- *  - Exactly one instance of ExecCtx must be created per thread. Instances must
- *    always be called exec_ctx.
  *  - Do not pass exec_ctx as a parameter to a function. Always access it using
  *    grpc_core::ExecCtx::Get().
+ *  - NOTE: In the future, the convention is likely to change to allow only one
+ *          ExecCtx on a thread's stack at the same time. The TODO below
+ *          discusses this plan in more detail.
+ *
+ * TODO(yashykt): Only allow one "active" ExecCtx on a thread at the same time.
+ *                Stage 1: If a new one is created on the stack, it should just
+ *                pass-through to the underlying ExecCtx deeper in the thread's
+ *                stack.
+ *                Stage 2: Assert if a 2nd one is ever created on the stack
+ *                since that implies a core re-entry outside of application
+ *                callbacks.
  */
 class ExecCtx {
  public:
@@ -226,6 +239,122 @@ class ExecCtx {
   GPR_TLS_CLASS_DECL(exec_ctx_);
   ExecCtx* last_exec_ctx_ = Get();
 };
+
+/** Application-callback execution context.
+ *  A bag of data that collects information along a callstack.
+ *  It is created on the stack at core entry points, and stored internally
+ *  as a thread-local variable.
+ *
+ *  There are three key differences between this structure and ExecCtx:
+ *    1. ApplicationCallbackExecCtx builds a list of application-level
+ *       callbacks, but ExecCtx builds a list of internal callbacks to invoke.
+ *    2. ApplicationCallbackExecCtx invokes its callbacks only at destruction;
+ *       there is no explicit Flush method.
+ *    3. If more than one ApplicationCallbackExecCtx is created on the thread's
+ *       stack, only the one closest to the base of the stack is actually
+ *       active and this is the only one that enqueues application callbacks.
+ *       (Unlike ExecCtx, it is not feasible to prevent multiple of these on the
+ *       stack since the executing application callback may itself enter core.
+ *       However, the new one created will just pass callbacks through to the
+ *       base one and those will not be executed until the return to the
+ *       destructor of the base one, preventing unlimited stack growth.)
+ *
+ *  This structure exists because application callbacks may themselves cause a
+ *  core re-entry (e.g., through a public API call) and if that call in turn
+ *  causes another application-callback, there could be arbitrarily growing
+ *  stacks of core re-entries. Instead, any application callbacks instead should
+ *  not be invoked until other core work is done and other application callbacks
+ *  have completed. To accomplish this, any application callback should be
+ *  enqueued using grpc_core::ApplicationCallbackExecCtx::Enqueue .
+ *
+ *  CONVENTIONS:
+ *  - Instances of this must ALWAYS be constructed on the stack, never
+ *    heap allocated.
+ *  - Instances of this are generally constructed before ExecCtx when needed.
+ *    The only exception is for ExecCtx's that are explicitly flushed and
+ *    that survive beyond the scope of the function that can cause application
+ *    callbacks to be invoked (e.g., in the timer thread).
+ *
+ *  Generally, core entry points that may trigger application-level callbacks
+ *  will have the following declarations:
+ *
+ *  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+ *  grpc_core::ExecCtx exec_ctx;
+ *
+ *  This ordering is important to make sure that the ApplicationCallbackExecCtx
+ *  is destroyed after the ExecCtx (to prevent the re-entry problem described
+ *  above, as well as making sure that ExecCtx core callbacks are invoked first)
+ *
+ */
+
+class ApplicationCallbackExecCtx {
+ public:
+  /** Default Constructor */
+  ApplicationCallbackExecCtx() { Set(this, flags_); }
+
+  /** Parameterised Constructor */
+  ApplicationCallbackExecCtx(uintptr_t fl) : flags_(fl) { Set(this, flags_); }
+
+  ~ApplicationCallbackExecCtx() {
+    if (reinterpret_cast<ApplicationCallbackExecCtx*>(
+            gpr_tls_get(&callback_exec_ctx_)) == this) {
+      while (head_ != nullptr) {
+        auto* f = head_;
+        head_ = f->internal_next;
+        if (f->internal_next == nullptr) {
+          tail_ = nullptr;
+        }
+        (*f->functor_run)(f, f->internal_success);
+      }
+      gpr_tls_set(&callback_exec_ctx_, reinterpret_cast<intptr_t>(nullptr));
+      if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
+        grpc_core::Fork::DecExecCtxCount();
+      }
+    } else {
+      GPR_DEBUG_ASSERT(head_ == nullptr);
+      GPR_DEBUG_ASSERT(tail_ == nullptr);
+    }
+  }
+
+  static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
+    if (reinterpret_cast<ApplicationCallbackExecCtx*>(
+            gpr_tls_get(&callback_exec_ctx_)) == nullptr) {
+      if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags)) {
+        grpc_core::Fork::IncExecCtxCount();
+      }
+      gpr_tls_set(&callback_exec_ctx_, reinterpret_cast<intptr_t>(exec_ctx));
+    }
+  }
+
+  static void Enqueue(grpc_experimental_completion_queue_functor* functor,
+                      int is_success) {
+    functor->internal_success = is_success;
+    functor->internal_next = nullptr;
+
+    auto* ctx = reinterpret_cast<ApplicationCallbackExecCtx*>(
+        gpr_tls_get(&callback_exec_ctx_));
+
+    if (ctx->head_ == nullptr) {
+      ctx->head_ = functor;
+    }
+    if (ctx->tail_ != nullptr) {
+      ctx->tail_->internal_next = functor;
+    }
+    ctx->tail_ = functor;
+  }
+
+  /** Global initialization for ApplicationCallbackExecCtx. Called by init. */
+  static void GlobalInit(void) { gpr_tls_init(&callback_exec_ctx_); }
+
+  /** Global shutdown for ApplicationCallbackExecCtx. Called by init. */
+  static void GlobalShutdown(void) { gpr_tls_destroy(&callback_exec_ctx_); }
+
+ private:
+  uintptr_t flags_{0u};
+  grpc_experimental_completion_queue_functor* head_{nullptr};
+  grpc_experimental_completion_queue_functor* tail_{nullptr};
+  GPR_TLS_CLASS_DECL(callback_exec_ctx_);
+};
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXEC_CTX_H */

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

@@ -32,35 +32,98 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr.h"
 
 #define MAX_DEPTH 2
 
-#define EXECUTOR_TRACE(format, ...)                     \
-  if (executor_trace.enabled()) {                       \
-    gpr_log(GPR_INFO, "EXECUTOR " format, __VA_ARGS__); \
-  }
+#define EXECUTOR_TRACE(format, ...)                       \
+  do {                                                    \
+    if (GRPC_TRACE_FLAG_ENABLED(executor_trace)) {        \
+      gpr_log(GPR_INFO, "EXECUTOR " format, __VA_ARGS__); \
+    }                                                     \
+  } while (0)
 
-#define EXECUTOR_TRACE0(str)            \
-  if (executor_trace.enabled()) {       \
-    gpr_log(GPR_INFO, "EXECUTOR " str); \
-  }
+#define EXECUTOR_TRACE0(str)                       \
+  do {                                             \
+    if (GRPC_TRACE_FLAG_ENABLED(executor_trace)) { \
+      gpr_log(GPR_INFO, "EXECUTOR " str);          \
+    }                                              \
+  } while (0)
 
-grpc_core::TraceFlag executor_trace(false, "executor");
+namespace grpc_core {
+namespace {
 
 GPR_TLS_DECL(g_this_thread_state);
 
-GrpcExecutor::GrpcExecutor(const char* name) : name_(name) {
+Executor* executors[static_cast<size_t>(ExecutorType::NUM_EXECUTORS)];
+
+void default_enqueue_short(grpc_closure* closure, grpc_error* error) {
+  executors[static_cast<size_t>(ExecutorType::DEFAULT)]->Enqueue(
+      closure, error, true /* is_short */);
+}
+
+void default_enqueue_long(grpc_closure* closure, grpc_error* error) {
+  executors[static_cast<size_t>(ExecutorType::DEFAULT)]->Enqueue(
+      closure, error, false /* is_short */);
+}
+
+void resolver_enqueue_short(grpc_closure* closure, grpc_error* error) {
+  executors[static_cast<size_t>(ExecutorType::RESOLVER)]->Enqueue(
+      closure, error, true /* is_short */);
+}
+
+void resolver_enqueue_long(grpc_closure* closure, grpc_error* error) {
+  executors[static_cast<size_t>(ExecutorType::RESOLVER)]->Enqueue(
+      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)]}}};
+
+}  // namespace
+
+TraceFlag executor_trace(false, "executor");
+
+Executor::Executor(const char* name) : name_(name) {
   adding_thread_lock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
   gpr_atm_rel_store(&num_threads_, 0);
   max_threads_ = GPR_MAX(1, 2 * gpr_cpu_num_cores());
 }
 
-void GrpcExecutor::Init() { SetThreading(true); }
+void Executor::Init() { SetThreading(true); }
 
-size_t GrpcExecutor::RunClosures(const char* executor_name,
-                                 grpc_closure_list list) {
+size_t Executor::RunClosures(const char* executor_name,
+                             grpc_closure_list list) {
   size_t n = 0;
 
+  // In the executor, the ExecCtx for the thread is declared in the executor
+  // thread itself, but this is the point where we could start seeing
+  // application-level callbacks. No need to create a new ExecCtx, though,
+  // since there already is one and it is flushed (but not destructed) in this
+  // function itself.
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx(
+      GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
+
   grpc_closure* c = list.head;
   while (c != nullptr) {
     grpc_closure* next = c->next_data.next;
@@ -82,11 +145,11 @@ size_t GrpcExecutor::RunClosures(const char* executor_name,
   return n;
 }
 
-bool GrpcExecutor::IsThreaded() const {
+bool Executor::IsThreaded() const {
   return gpr_atm_acq_load(&num_threads_) > 0;
 }
 
-void GrpcExecutor::SetThreading(bool threading) {
+void Executor::SetThreading(bool threading) {
   gpr_atm curr_num_threads = gpr_atm_acq_load(&num_threads_);
   EXECUTOR_TRACE("(%s) SetThreading(%d) begin", name_, threading);
 
@@ -112,7 +175,7 @@ void GrpcExecutor::SetThreading(bool threading) {
     }
 
     thd_state_[0].thd =
-        grpc_core::Thread(name_, &GrpcExecutor::ThreadMain, &thd_state_[0]);
+        grpc_core::Thread(name_, &Executor::ThreadMain, &thd_state_[0]);
     thd_state_[0].thd.Start();
   } else {  // !threading
     if (curr_num_threads == 0) {
@@ -148,14 +211,22 @@ void GrpcExecutor::SetThreading(bool threading) {
 
     gpr_free(thd_state_);
     gpr_tls_destroy(&g_this_thread_state);
+
+    // grpc_iomgr_shutdown_background_closure() will close all the registered
+    // fds in the background poller, and wait for all pending closures to
+    // finish. Thus, never call Executor::SetThreading(false) in the middle of
+    // an application.
+    // TODO(guantaol): create another method to finish all the pending closures
+    // registered in the background poller by grpc_core::Executor.
+    grpc_iomgr_shutdown_background_closure();
   }
 
   EXECUTOR_TRACE("(%s) SetThreading(%d) done", name_, threading);
 }
 
-void GrpcExecutor::Shutdown() { SetThreading(false); }
+void Executor::Shutdown() { SetThreading(false); }
 
-void GrpcExecutor::ThreadMain(void* arg) {
+void Executor::ThreadMain(void* arg) {
   ThreadState* ts = static_cast<ThreadState*>(arg);
   gpr_tls_set(&g_this_thread_state, reinterpret_cast<intptr_t>(ts));
 
@@ -192,8 +263,8 @@ void GrpcExecutor::ThreadMain(void* arg) {
   }
 }
 
-void GrpcExecutor::Enqueue(grpc_closure* closure, grpc_error* error,
-                           bool is_short) {
+void Executor::Enqueue(grpc_closure* closure, grpc_error* error,
+                       bool is_short) {
   bool retry_push;
   if (is_short) {
     GRPC_STATS_INC_EXECUTOR_SCHEDULED_SHORT_ITEMS();
@@ -220,6 +291,10 @@ void GrpcExecutor::Enqueue(grpc_closure* closure, grpc_error* error,
       return;
     }
 
+    if (grpc_iomgr_add_closure_to_background_poller(closure, error)) {
+      return;
+    }
+
     ThreadState* ts = (ThreadState*)gpr_tls_get(&g_this_thread_state);
     if (ts == nullptr) {
       ts = &thd_state_[GPR_HASH_POINTER(grpc_core::ExecCtx::Get(),
@@ -304,7 +379,7 @@ void GrpcExecutor::Enqueue(grpc_closure* closure, grpc_error* error,
         gpr_atm_rel_store(&num_threads_, cur_thread_count + 1);
 
         thd_state_[cur_thread_count].thd = grpc_core::Thread(
-            name_, &GrpcExecutor::ThreadMain, &thd_state_[cur_thread_count]);
+            name_, &Executor::ThreadMain, &thd_state_[cur_thread_count]);
         thd_state_[cur_thread_count].thd.Start();
       }
       gpr_spinlock_unlock(&adding_thread_lock_);
@@ -316,85 +391,52 @@ void GrpcExecutor::Enqueue(grpc_closure* closure, grpc_error* error,
   } while (retry_push);
 }
 
-static GrpcExecutor* executors[GRPC_NUM_EXECUTORS];
-
-void default_enqueue_short(grpc_closure* closure, grpc_error* error) {
-  executors[GRPC_DEFAULT_EXECUTOR]->Enqueue(closure, error,
-                                            true /* is_short */);
-}
-
-void default_enqueue_long(grpc_closure* closure, grpc_error* error) {
-  executors[GRPC_DEFAULT_EXECUTOR]->Enqueue(closure, error,
-                                            false /* is_short */);
-}
-
-void resolver_enqueue_short(grpc_closure* closure, grpc_error* error) {
-  executors[GRPC_RESOLVER_EXECUTOR]->Enqueue(closure, error,
-                                             true /* is_short */);
-}
-
-void resolver_enqueue_long(grpc_closure* closure, grpc_error* error) {
-  executors[GRPC_RESOLVER_EXECUTOR]->Enqueue(closure, error,
-                                             false /* is_short */);
-}
-
-static const grpc_closure_scheduler_vtable
-    vtables_[GRPC_NUM_EXECUTORS][GRPC_NUM_EXECUTOR_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"}}};
-
-static grpc_closure_scheduler
-    schedulers_[GRPC_NUM_EXECUTORS][GRPC_NUM_EXECUTOR_JOB_TYPES] = {
-        {{&vtables_[GRPC_DEFAULT_EXECUTOR][GRPC_EXECUTOR_SHORT]},
-         {&vtables_[GRPC_DEFAULT_EXECUTOR][GRPC_EXECUTOR_LONG]}},
-        {{&vtables_[GRPC_RESOLVER_EXECUTOR][GRPC_EXECUTOR_SHORT]},
-         {&vtables_[GRPC_RESOLVER_EXECUTOR][GRPC_EXECUTOR_LONG]}}};
-
-// grpc_executor_init() and grpc_executor_shutdown() functions are called in the
+// Executor::InitAll() and Executor::ShutdownAll() functions are called in the
 // the grpc_init() and grpc_shutdown() code paths which are protected by a
 // global mutex. So it is okay to assume that these functions are thread-safe
-void grpc_executor_init() {
-  EXECUTOR_TRACE0("grpc_executor_init() enter");
+void Executor::InitAll() {
+  EXECUTOR_TRACE0("Executor::InitAll() enter");
 
-  // Return if grpc_executor_init() is already called earlier
-  if (executors[GRPC_DEFAULT_EXECUTOR] != nullptr) {
-    GPR_ASSERT(executors[GRPC_RESOLVER_EXECUTOR] != nullptr);
+  // Return if Executor::InitAll() is already called earlier
+  if (executors[static_cast<size_t>(ExecutorType::DEFAULT)] != nullptr) {
+    GPR_ASSERT(executors[static_cast<size_t>(ExecutorType::RESOLVER)] !=
+               nullptr);
     return;
   }
 
-  executors[GRPC_DEFAULT_EXECUTOR] =
-      grpc_core::New<GrpcExecutor>("default-executor");
-  executors[GRPC_RESOLVER_EXECUTOR] =
-      grpc_core::New<GrpcExecutor>("resolver-executor");
+  executors[static_cast<size_t>(ExecutorType::DEFAULT)] =
+      grpc_core::New<Executor>("default-executor");
+  executors[static_cast<size_t>(ExecutorType::RESOLVER)] =
+      grpc_core::New<Executor>("resolver-executor");
 
-  executors[GRPC_DEFAULT_EXECUTOR]->Init();
-  executors[GRPC_RESOLVER_EXECUTOR]->Init();
+  executors[static_cast<size_t>(ExecutorType::DEFAULT)]->Init();
+  executors[static_cast<size_t>(ExecutorType::RESOLVER)]->Init();
 
-  EXECUTOR_TRACE0("grpc_executor_init() done");
+  EXECUTOR_TRACE0("Executor::InitAll() done");
 }
 
-grpc_closure_scheduler* grpc_executor_scheduler(GrpcExecutorType executor_type,
-                                                GrpcExecutorJobType job_type) {
-  return &schedulers_[executor_type][job_type];
+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* grpc_executor_scheduler(GrpcExecutorJobType job_type) {
-  return grpc_executor_scheduler(GRPC_DEFAULT_EXECUTOR, job_type);
+grpc_closure_scheduler* Executor::Scheduler(ExecutorJobType job_type) {
+  return Executor::Scheduler(ExecutorType::DEFAULT, job_type);
 }
 
-void grpc_executor_shutdown() {
-  EXECUTOR_TRACE0("grpc_executor_shutdown() enter");
+void Executor::ShutdownAll() {
+  EXECUTOR_TRACE0("Executor::ShutdownAll() enter");
 
-  // Return if grpc_executor_shutdown() is already called earlier
-  if (executors[GRPC_DEFAULT_EXECUTOR] == nullptr) {
-    GPR_ASSERT(executors[GRPC_RESOLVER_EXECUTOR] == nullptr);
+  // Return if Executor:SshutdownAll() is already called earlier
+  if (executors[static_cast<size_t>(ExecutorType::DEFAULT)] == nullptr) {
+    GPR_ASSERT(executors[static_cast<size_t>(ExecutorType::RESOLVER)] ==
+               nullptr);
     return;
   }
 
-  executors[GRPC_DEFAULT_EXECUTOR]->Shutdown();
-  executors[GRPC_RESOLVER_EXECUTOR]->Shutdown();
+  executors[static_cast<size_t>(ExecutorType::DEFAULT)]->Shutdown();
+  executors[static_cast<size_t>(ExecutorType::RESOLVER)]->Shutdown();
 
   // Delete the executor objects.
   //
@@ -408,26 +450,36 @@ void grpc_executor_shutdown() {
   // By ensuring that all executors are shutdown first, we are also ensuring
   // that no thread is active across all executors.
 
-  grpc_core::Delete<GrpcExecutor>(executors[GRPC_DEFAULT_EXECUTOR]);
-  grpc_core::Delete<GrpcExecutor>(executors[GRPC_RESOLVER_EXECUTOR]);
-  executors[GRPC_DEFAULT_EXECUTOR] = nullptr;
-  executors[GRPC_RESOLVER_EXECUTOR] = nullptr;
+  grpc_core::Delete<Executor>(
+      executors[static_cast<size_t>(ExecutorType::DEFAULT)]);
+  grpc_core::Delete<Executor>(
+      executors[static_cast<size_t>(ExecutorType::RESOLVER)]);
+  executors[static_cast<size_t>(ExecutorType::DEFAULT)] = nullptr;
+  executors[static_cast<size_t>(ExecutorType::RESOLVER)] = nullptr;
 
-  EXECUTOR_TRACE0("grpc_executor_shutdown() done");
+  EXECUTOR_TRACE0("Executor::ShutdownAll() done");
 }
 
-bool grpc_executor_is_threaded(GrpcExecutorType executor_type) {
-  GPR_ASSERT(executor_type < GRPC_NUM_EXECUTORS);
-  return executors[executor_type]->IsThreaded();
+bool Executor::IsThreaded(ExecutorType executor_type) {
+  GPR_ASSERT(executor_type < ExecutorType::NUM_EXECUTORS);
+  return executors[static_cast<size_t>(executor_type)]->IsThreaded();
 }
 
-bool grpc_executor_is_threaded() {
-  return grpc_executor_is_threaded(GRPC_DEFAULT_EXECUTOR);
+bool Executor::IsThreadedDefault() {
+  return Executor::IsThreaded(ExecutorType::DEFAULT);
 }
 
-void grpc_executor_set_threading(bool enable) {
-  EXECUTOR_TRACE("grpc_executor_set_threading(%d) called", enable);
-  for (int i = 0; i < GRPC_NUM_EXECUTORS; i++) {
+void Executor::SetThreadingAll(bool enable) {
+  EXECUTOR_TRACE("Executor::SetThreadingAll(%d) called", enable);
+  for (size_t i = 0; i < static_cast<size_t>(ExecutorType::NUM_EXECUTORS);
+       i++) {
     executors[i]->SetThreading(enable);
   }
 }
+
+void Executor::SetThreadingDefault(bool enable) {
+  EXECUTOR_TRACE("Executor::SetThreadingDefault(%d) called", enable);
+  executors[static_cast<size_t>(ExecutorType::DEFAULT)]->SetThreading(enable);
+}
+
+}  // namespace grpc_core