grpc 1.15.0 → 1.30.0

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

@@ -31,31 +31,36 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
 #include "src/core/lib/iomgr/ev_epollex_linux.h"
-#include "src/core/lib/iomgr/ev_epollsig_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
+#include "src/core/lib/iomgr/internal_errqueue.h"
 
-grpc_core::TraceFlag grpc_polling_trace(false,
-                                        "polling"); /* Disabled by default */
+GPR_GLOBAL_CONFIG_DEFINE_STRING(
+    grpc_poll_strategy, "all",
+    "Declares which polling engines to try when starting gRPC. "
+    "This is a comma-separated list of engines, which are tried in priority "
+    "order first -> last.")
+
+grpc_core::DebugOnlyTraceFlag grpc_polling_trace(
+    false, "polling"); /* Disabled by default */
 
 /* Traces fd create/close operations */
-grpc_core::TraceFlag grpc_fd_trace(false, "fd_trace");
+grpc_core::DebugOnlyTraceFlag grpc_fd_trace(false, "fd_trace");
 grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount(false, "fd_refcount");
 grpc_core::DebugOnlyTraceFlag grpc_polling_api_trace(false, "polling_api");
 
-#ifndef NDEBUG
-
 // Polling API trace only enabled in debug builds
+#ifndef NDEBUG
 #define GRPC_POLLING_API_TRACE(format, ...)                  \
-  if (grpc_polling_api_trace.enabled()) {                    \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_api_trace)) {     \
     gpr_log(GPR_INFO, "(polling-api) " format, __VA_ARGS__); \
   }
 #else
 #define GRPC_POLLING_API_TRACE(...)
-#endif
+#endif  // NDEBUG
 
 /** Default poll() function - a pointer so that it can be overridden by some
  *  tests */
@@ -66,7 +71,7 @@ int aix_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
   return poll(fds, nfds, timeout);
 }
 grpc_poll_function_type grpc_poll_function = aix_poll;
-#endif
+#endif  // GPR_AIX
 
 grpc_wakeup_fd grpc_global_wakeup_fd;
 
@@ -76,11 +81,10 @@ static const char* g_poll_strategy_name = nullptr;
 typedef const grpc_event_engine_vtable* (*event_engine_factory_fn)(
     bool explicit_request);
 
-typedef struct {
+struct event_engine_factory {
   const char* name;
   event_engine_factory_fn factory;
-} event_engine_factory;
-
+};
 namespace {
 
 grpc_poll_function_type real_poll_function;
@@ -123,13 +127,12 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
 // environment variable if that variable is set (which should be a
 // comma-separated list of one or more event engine names)
 static event_engine_factory g_factories[] = {
-    {ENGINE_HEAD_CUSTOM, nullptr},          {ENGINE_HEAD_CUSTOM, nullptr},
-    {ENGINE_HEAD_CUSTOM, nullptr},          {ENGINE_HEAD_CUSTOM, nullptr},
-    {"epollex", grpc_init_epollex_linux},   {"epoll1", grpc_init_epoll1_linux},
-    {"epollsig", grpc_init_epollsig_linux}, {"poll", grpc_init_poll_posix},
-    {"poll-cv", grpc_init_poll_cv_posix},   {"none", init_non_polling},
-    {ENGINE_TAIL_CUSTOM, nullptr},          {ENGINE_TAIL_CUSTOM, nullptr},
-    {ENGINE_TAIL_CUSTOM, nullptr},          {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
+    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
+    {"epollex", grpc_init_epollex_linux}, {"epoll1", grpc_init_epoll1_linux},
+    {"poll", grpc_init_poll_posix},       {"none", init_non_polling},
+    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
 };
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
@@ -202,18 +205,16 @@ void grpc_register_event_engine_factory(const char* name,
   GPR_ASSERT(false);
 }
 
-/* Call this only after calling grpc_event_engine_init() */
+/*If grpc_event_engine_init() has been called, returns the poll_strategy_name.
+ * Otherwise, returns nullptr. */
 const char* grpc_get_poll_strategy_name() { return g_poll_strategy_name; }
 
 void grpc_event_engine_init(void) {
-  char* s = gpr_getenv("GRPC_POLL_STRATEGY");
-  if (s == nullptr) {
-    s = gpr_strdup("all");
-  }
+  grpc_core::UniquePtr<char> value = GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
 
   char** strings = nullptr;
   size_t nstrings = 0;
-  split(s, &strings, &nstrings);
+  split(value.get(), &strings, &nstrings);
 
   for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
     try_engine(strings[i]);
@@ -225,10 +226,10 @@ void grpc_event_engine_init(void) {
   gpr_free(strings);
 
   if (g_event_engine == nullptr) {
-    gpr_log(GPR_ERROR, "No event engine could be initialized from %s", s);
+    gpr_log(GPR_ERROR, "No event engine could be initialized from %s",
+            value.get());
     abort();
   }
-  gpr_free(s);
 }
 
 void grpc_event_engine_shutdown(void) {
@@ -237,14 +238,23 @@ void grpc_event_engine_shutdown(void) {
 }
 
 bool grpc_event_engine_can_track_errors(void) {
-  return g_event_engine->can_track_err;
+  /* Only track errors if platform supports errqueue. */
+  if (grpc_core::kernel_supports_errqueue()) {
+    return g_event_engine->can_track_err;
+  }
+  return false;
+}
+
+bool grpc_event_engine_run_in_background(void) {
+  // g_event_engine is nullptr when using a custom iomgr.
+  return g_event_engine != nullptr && g_event_engine->run_in_background;
 }
 
 grpc_fd* grpc_fd_create(int fd, const char* name, bool track_err) {
   GRPC_POLLING_API_TRACE("fd_create(%d, %s, %d)", fd, name, track_err);
   GRPC_FD_TRACE("fd_create(%d, %s, %d)", fd, name, track_err);
-  GPR_DEBUG_ASSERT(!track_err || g_event_engine->can_track_err);
-  return g_event_engine->fd_create(fd, name, track_err);
+  return g_event_engine->fd_create(
+      fd, name, track_err && grpc_event_engine_can_track_errors());
 }
 
 int grpc_fd_wrapped_fd(grpc_fd* fd) {
@@ -391,4 +401,17 @@ void grpc_pollset_set_del_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
   g_event_engine->pollset_set_del_fd(pollset_set, fd);
 }
 
+bool grpc_is_any_background_poller_thread(void) {
+  return g_event_engine->is_any_background_poller_thread();
+}
+
+bool grpc_add_closure_to_background_poller(grpc_closure* closure,
+                                           grpc_error* error) {
+  return g_event_engine->add_closure_to_background_poller(closure, error);
+}
+
+void grpc_shutdown_background_closure(void) {
+  g_event_engine->shutdown_background_closure();
+}
+
 #endif  // GRPC_POSIX_SOCKET_EV

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__); \
   }
 
@@ -42,6 +46,7 @@ typedef struct grpc_fd grpc_fd;
 typedef struct grpc_event_engine_vtable {
   size_t pollset_size;
   bool can_track_err;
+  bool run_in_background;
 
   grpc_fd* (*fd_create)(int fd, const char* name, bool track_err);
   int (*fd_wrapped_fd)(grpc_fd* fd);
@@ -79,7 +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 */
@@ -101,6 +110,11 @@ const char* grpc_get_poll_strategy_name();
  */
 bool grpc_event_engine_can_track_errors();
 
+/* Returns true if polling engine runs in the background, false otherwise.
+ * Currently only 'epollbg' runs in the background.
+ */
+bool grpc_event_engine_run_in_background();
+
 /* Create a wrapped file descriptor.
    Requires fd is a non-blocking file descriptor.
    \a track_err if true means that error events would be tracked separately
@@ -174,6 +188,18 @@ 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();
+
 /* override to allow tests to hook poll() usage */
 typedef int (*grpc_poll_function_type)(struct pollfd*, nfds_t, int);
 extern grpc_poll_function_type grpc_poll_function;

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

@@ -52,9 +52,9 @@ static void exec_ctx_sched(grpc_closure* closure, grpc_error* error) {
 }
 
 static gpr_timespec g_start_time;
+static gpr_cycle_counter g_start_cycle;
 
-static grpc_millis timespec_to_millis_round_down(gpr_timespec ts) {
-  ts = gpr_time_sub(ts, g_start_time);
+static grpc_millis timespan_to_millis_round_down(gpr_timespec ts) {
   double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
              static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS;
   if (x < 0) return 0;
@@ -62,8 +62,11 @@ static grpc_millis timespec_to_millis_round_down(gpr_timespec ts) {
   return static_cast<grpc_millis>(x);
 }
 
-static grpc_millis timespec_to_millis_round_up(gpr_timespec ts) {
-  ts = gpr_time_sub(ts, g_start_time);
+static grpc_millis timespec_to_millis_round_down(gpr_timespec ts) {
+  return timespan_to_millis_round_down(gpr_time_sub(ts, g_start_time));
+}
+
+static grpc_millis timespan_to_millis_round_up(gpr_timespec ts) {
   double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
              static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS +
              static_cast<double>(GPR_NS_PER_SEC - 1) /
@@ -73,6 +76,10 @@ static grpc_millis timespec_to_millis_round_up(gpr_timespec ts) {
   return static_cast<grpc_millis>(x);
 }
 
+static grpc_millis timespec_to_millis_round_up(gpr_timespec ts) {
+  return timespan_to_millis_round_up(gpr_time_sub(ts, g_start_time));
+}
+
 gpr_timespec grpc_millis_to_timespec(grpc_millis millis,
                                      gpr_clock_type clock_type) {
   // special-case infinities as grpc_millis can be 32bit on some platforms
@@ -101,13 +108,19 @@ grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec ts) {
       gpr_convert_clock_type(ts, g_start_time.clock_type));
 }
 
-static const grpc_closure_scheduler_vtable exec_ctx_scheduler_vtable = {
-    exec_ctx_run, exec_ctx_sched, "exec_ctx"};
-static grpc_closure_scheduler exec_ctx_scheduler = {&exec_ctx_scheduler_vtable};
-grpc_closure_scheduler* grpc_schedule_on_exec_ctx = &exec_ctx_scheduler;
+grpc_millis grpc_cycle_counter_to_millis_round_down(gpr_cycle_counter cycles) {
+  return timespan_to_millis_round_down(
+      gpr_cycle_counter_sub(cycles, g_start_cycle));
+}
+
+grpc_millis grpc_cycle_counter_to_millis_round_up(gpr_cycle_counter cycles) {
+  return timespan_to_millis_round_up(
+      gpr_cycle_counter_sub(cycles, g_start_cycle));
+}
 
 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) {
@@ -116,7 +129,13 @@ void ExecCtx::TestOnlyGlobalInit(gpr_timespec new_val) {
 }
 
 void ExecCtx::GlobalInit(void) {
+  // gpr_now(GPR_CLOCK_MONOTONIC) incurs a syscall. We don't actually know the
+  // exact cycle the time was captured, so we use the average of cycles before
+  // and after the syscall as the starting cycle.
+  const gpr_cycle_counter cycle_before = gpr_get_cycle_counter();
   g_start_time = gpr_now(GPR_CLOCK_MONOTONIC);
+  const gpr_cycle_counter cycle_after = gpr_get_cycle_counter();
+  g_start_cycle = (cycle_before + cycle_after) / 2;
   gpr_tls_init(&exec_ctx_);
 }
 
@@ -150,4 +169,56 @@ grpc_millis ExecCtx::Now() {
   return now_;
 }
 
+void ExecCtx::Run(const DebugLocation& location, grpc_closure* closure,
+                  grpc_error* error) {
+  (void)location;
+  if (closure == nullptr) {
+    GRPC_ERROR_UNREF(error);
+    return;
+  }
+#ifndef NDEBUG
+  if (closure->scheduled) {
+    gpr_log(GPR_ERROR,
+            "Closure already scheduled. (closure: %p, created: [%s:%d], "
+            "previously scheduled at: [%s: %d], newly scheduled at [%s: %d]",
+            closure, closure->file_created, closure->line_created,
+            closure->file_initiated, closure->line_initiated, location.file(),
+            location.line());
+    abort();
+  }
+  closure->scheduled = true;
+  closure->file_initiated = location.file();
+  closure->line_initiated = location.line();
+  closure->run = false;
+  GPR_ASSERT(closure->cb != nullptr);
+#endif
+  exec_ctx_sched(closure, error);
+}
+
+void ExecCtx::RunList(const DebugLocation& location, grpc_closure_list* list) {
+  (void)location;
+  grpc_closure* c = list->head;
+  while (c != nullptr) {
+    grpc_closure* next = c->next_data.next;
+#ifndef NDEBUG
+    if (c->scheduled) {
+      gpr_log(GPR_ERROR,
+              "Closure already scheduled. (closure: %p, created: [%s:%d], "
+              "previously scheduled at: [%s: %d], newly scheduled at [%s:%d]",
+              c, c->file_created, c->line_created, c->file_initiated,
+              c->line_initiated, location.file(), location.line());
+      abort();
+    }
+    c->scheduled = true;
+    c->file_initiated = location.file();
+    c->line_initiated = location.line();
+    c->run = false;
+    GPR_ASSERT(c->cb != nullptr);
+#endif
+    exec_ctx_sched(c, c->error_data.error);
+    c = next;
+  }
+  list->head = list->tail = nullptr;
+}
+
 }  // namespace grpc_core

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

@@ -21,11 +21,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <limits>
+
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gpr/tls.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/iomgr/closure.h"
 
@@ -34,9 +39,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,17 +53,22 @@ typedef struct grpc_combiner grpc_combiner;
    be counted by fork handlers */
 #define GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD 4
 
-extern grpc_closure_scheduler* grpc_schedule_on_exec_ctx;
+/* 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
 
 gpr_timespec grpc_millis_to_timespec(grpc_millis millis, gpr_clock_type clock);
 grpc_millis grpc_timespec_to_millis_round_down(gpr_timespec timespec);
 grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec timespec);
+grpc_millis grpc_cycle_counter_to_millis_round_down(gpr_cycle_counter cycles);
+grpc_millis grpc_cycle_counter_to_millis_round_up(gpr_cycle_counter cycles);
 
 namespace grpc_core {
+class Combiner;
 /** 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 +79,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 +89,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:
@@ -116,18 +134,18 @@ class ExecCtx {
   ExecCtx(const ExecCtx&) = delete;
   ExecCtx& operator=(const ExecCtx&) = delete;
 
-  /** Return starting_cpu. This is only required for stats collection and is
-   *  hence only defined if GRPC_COLLECT_STATS is enabled.
-   */
-#if defined(GRPC_COLLECT_STATS) || !defined(NDEBUG)
-  unsigned starting_cpu() const { return starting_cpu_; }
-#endif /* defined(GRPC_COLLECT_STATS) || !defined(NDEBUG) */
+  unsigned starting_cpu() {
+    if (starting_cpu_ == std::numeric_limits<unsigned>::max()) {
+      starting_cpu_ = gpr_cpu_current_cpu();
+    }
+    return starting_cpu_;
+  }
 
   struct CombinerData {
     /* currently active combiner: updated only via combiner.c */
-    grpc_combiner* active_combiner;
+    Combiner* active_combiner;
     /* last active combiner in the active combiner list */
-    grpc_combiner* last_combiner;
+    Combiner* last_combiner;
   };
 
   /** Only to be used by grpc-combiner code */
@@ -209,12 +227,17 @@ class ExecCtx {
     gpr_tls_set(&exec_ctx_, reinterpret_cast<intptr_t>(exec_ctx));
   }
 
+  static void Run(const DebugLocation& location, grpc_closure* closure,
+                  grpc_error* error);
+
+  static void RunList(const DebugLocation& location, grpc_closure_list* list);
+
  protected:
   /** Check if ready to finish. */
   virtual bool CheckReadyToFinish() { return false; }
 
   /** Disallow delete on ExecCtx. */
-  static void operator delete(void* p) { abort(); }
+  static void operator delete(void* /* p */) { abort(); }
 
  private:
   /** Set exec_ctx_ to exec_ctx. */
@@ -223,9 +246,7 @@ class ExecCtx {
   CombinerData combiner_data_ = {nullptr, nullptr};
   uintptr_t flags_;
 
-#if defined(GRPC_COLLECT_STATS) || !defined(NDEBUG)
-  unsigned starting_cpu_ = gpr_cpu_current_cpu();
-#endif /* defined(GRPC_COLLECT_STATS) || !defined(NDEBUG) */
+  unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
 
   bool now_is_valid_ = false;
   grpc_millis now_ = 0;
@@ -233,6 +254,127 @@ 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_); }
+
+  static bool Available() {
+    return reinterpret_cast<ApplicationCallbackExecCtx*>(
+               gpr_tls_get(&callback_exec_ctx_)) != nullptr;
+  }
+
+ 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 */