grpc 1.8.7 → 1.9.0.pre1

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

@@ -21,15 +21,7 @@
 
 #include "src/core/lib/iomgr/ev_posix.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 const grpc_event_engine_vtable* grpc_init_poll_posix(bool explicit_request);
 const grpc_event_engine_vtable* grpc_init_poll_cv_posix(bool explicit_request);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_IOMGR_EV_POLL_POSIX_H */

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

@@ -30,11 +30,11 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/env.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/support/env.h"
 
 grpc_core::TraceFlag grpc_polling_trace(false,
                                         "polling"); /* Disabled by default */
@@ -46,7 +46,7 @@ grpc_poll_function_type grpc_poll_function = poll;
 
 grpc_wakeup_fd grpc_global_wakeup_fd;
 
-static const grpc_event_engine_vtable* g_event_engine;
+static const grpc_event_engine_vtable* g_event_engine = nullptr;
 static const char* g_poll_strategy_name = nullptr;
 
 typedef const grpc_event_engine_vtable* (*event_engine_factory_fn)(
@@ -59,8 +59,6 @@ typedef struct {
 
 namespace {
 
-extern "C" {
-
 grpc_poll_function_type real_poll_function;
 
 int dummy_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
@@ -72,7 +70,6 @@ int dummy_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
     return -1;
   }
 }
-}  // extern "C"
 
 const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
   if (!explicit_request) {
@@ -187,28 +184,25 @@ int grpc_fd_wrapped_fd(grpc_fd* fd) {
   return g_event_engine->fd_wrapped_fd(fd);
 }
 
-void grpc_fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_closure* on_done,
-                    int* release_fd, bool already_closed, const char* reason) {
-  g_event_engine->fd_orphan(exec_ctx, fd, on_done, release_fd, already_closed,
-                            reason);
+void grpc_fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
+                    bool already_closed, const char* reason) {
+  g_event_engine->fd_orphan(fd, on_done, release_fd, already_closed, reason);
 }
 
-void grpc_fd_shutdown(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_error* why) {
-  g_event_engine->fd_shutdown(exec_ctx, fd, why);
+void grpc_fd_shutdown(grpc_fd* fd, grpc_error* why) {
+  g_event_engine->fd_shutdown(fd, why);
 }
 
 bool grpc_fd_is_shutdown(grpc_fd* fd) {
   return g_event_engine->fd_is_shutdown(fd);
 }
 
-void grpc_fd_notify_on_read(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
-                            grpc_closure* closure) {
-  g_event_engine->fd_notify_on_read(exec_ctx, fd, closure);
+void grpc_fd_notify_on_read(grpc_fd* fd, grpc_closure* closure) {
+  g_event_engine->fd_notify_on_read(fd, closure);
 }
 
-void grpc_fd_notify_on_write(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
-                             grpc_closure* closure) {
-  g_event_engine->fd_notify_on_write(exec_ctx, fd, closure);
+void grpc_fd_notify_on_write(grpc_fd* fd, grpc_closure* closure) {
+  g_event_engine->fd_notify_on_write(fd, closure);
 }
 
 size_t grpc_pollset_size(void) { return g_event_engine->pollset_size; }
@@ -217,72 +211,63 @@ void grpc_pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   g_event_engine->pollset_init(pollset, mu);
 }
 
-void grpc_pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
-                           grpc_closure* closure) {
-  g_event_engine->pollset_shutdown(exec_ctx, pollset, closure);
+void grpc_pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
+  g_event_engine->pollset_shutdown(pollset, closure);
 }
 
-void grpc_pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {
-  g_event_engine->pollset_destroy(exec_ctx, pollset);
+void grpc_pollset_destroy(grpc_pollset* pollset) {
+  g_event_engine->pollset_destroy(pollset);
 }
 
-grpc_error* grpc_pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+grpc_error* grpc_pollset_work(grpc_pollset* pollset,
                               grpc_pollset_worker** worker,
                               grpc_millis deadline) {
-  return g_event_engine->pollset_work(exec_ctx, pollset, worker, deadline);
+  return g_event_engine->pollset_work(pollset, worker, deadline);
 }
 
-grpc_error* grpc_pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+grpc_error* grpc_pollset_kick(grpc_pollset* pollset,
                               grpc_pollset_worker* specific_worker) {
-  return g_event_engine->pollset_kick(exec_ctx, pollset, specific_worker);
+  return g_event_engine->pollset_kick(pollset, specific_worker);
 }
 
-void grpc_pollset_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
-                         struct grpc_fd* fd) {
-  g_event_engine->pollset_add_fd(exec_ctx, pollset, fd);
+void grpc_pollset_add_fd(grpc_pollset* pollset, struct grpc_fd* fd) {
+  g_event_engine->pollset_add_fd(pollset, fd);
 }
 
 grpc_pollset_set* grpc_pollset_set_create(void) {
   return g_event_engine->pollset_set_create();
 }
 
-void grpc_pollset_set_destroy(grpc_exec_ctx* exec_ctx,
-                              grpc_pollset_set* pollset_set) {
-  g_event_engine->pollset_set_destroy(exec_ctx, pollset_set);
+void grpc_pollset_set_destroy(grpc_pollset_set* pollset_set) {
+  g_event_engine->pollset_set_destroy(pollset_set);
 }
 
-void grpc_pollset_set_add_pollset(grpc_exec_ctx* exec_ctx,
-                                  grpc_pollset_set* pollset_set,
+void grpc_pollset_set_add_pollset(grpc_pollset_set* pollset_set,
                                   grpc_pollset* pollset) {
-  g_event_engine->pollset_set_add_pollset(exec_ctx, pollset_set, pollset);
+  g_event_engine->pollset_set_add_pollset(pollset_set, pollset);
 }
 
-void grpc_pollset_set_del_pollset(grpc_exec_ctx* exec_ctx,
-                                  grpc_pollset_set* pollset_set,
+void grpc_pollset_set_del_pollset(grpc_pollset_set* pollset_set,
                                   grpc_pollset* pollset) {
-  g_event_engine->pollset_set_del_pollset(exec_ctx, pollset_set, pollset);
+  g_event_engine->pollset_set_del_pollset(pollset_set, pollset);
 }
 
-void grpc_pollset_set_add_pollset_set(grpc_exec_ctx* exec_ctx,
-                                      grpc_pollset_set* bag,
+void grpc_pollset_set_add_pollset_set(grpc_pollset_set* bag,
                                       grpc_pollset_set* item) {
-  g_event_engine->pollset_set_add_pollset_set(exec_ctx, bag, item);
+  g_event_engine->pollset_set_add_pollset_set(bag, item);
 }
 
-void grpc_pollset_set_del_pollset_set(grpc_exec_ctx* exec_ctx,
-                                      grpc_pollset_set* bag,
+void grpc_pollset_set_del_pollset_set(grpc_pollset_set* bag,
                                       grpc_pollset_set* item) {
-  g_event_engine->pollset_set_del_pollset_set(exec_ctx, bag, item);
+  g_event_engine->pollset_set_del_pollset_set(bag, item);
 }
 
-void grpc_pollset_set_add_fd(grpc_exec_ctx* exec_ctx,
-                             grpc_pollset_set* pollset_set, grpc_fd* fd) {
-  g_event_engine->pollset_set_add_fd(exec_ctx, pollset_set, fd);
+void grpc_pollset_set_add_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
+  g_event_engine->pollset_set_add_fd(pollset_set, fd);
 }
 
-void grpc_pollset_set_del_fd(grpc_exec_ctx* exec_ctx,
-                             grpc_pollset_set* pollset_set, grpc_fd* fd) {
-  g_event_engine->pollset_set_del_fd(exec_ctx, pollset_set, fd);
+void grpc_pollset_set_del_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
+  g_event_engine->pollset_set_del_fd(pollset_set, fd);
 }
 
 #endif  // GRPC_POSIX_SOCKET

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

@@ -27,10 +27,6 @@
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern grpc_core::TraceFlag grpc_polling_trace; /* Disabled by default */
 
 typedef struct grpc_fd grpc_fd;
@@ -40,48 +36,36 @@ typedef struct grpc_event_engine_vtable {
 
   grpc_fd* (*fd_create)(int fd, const char* name);
   int (*fd_wrapped_fd)(grpc_fd* fd);
-  void (*fd_orphan)(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_closure* on_done,
-                    int* release_fd, bool already_closed, const char* reason);
-  void (*fd_shutdown)(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_error* why);
-  void (*fd_notify_on_read)(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
-                            grpc_closure* closure);
-  void (*fd_notify_on_write)(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
-                             grpc_closure* closure);
+  void (*fd_orphan)(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
+                    bool already_closed, const char* reason);
+  void (*fd_shutdown)(grpc_fd* fd, grpc_error* why);
+  void (*fd_notify_on_read)(grpc_fd* fd, grpc_closure* closure);
+  void (*fd_notify_on_write)(grpc_fd* fd, grpc_closure* closure);
   bool (*fd_is_shutdown)(grpc_fd* fd);
-  grpc_pollset* (*fd_get_read_notifier_pollset)(grpc_exec_ctx* exec_ctx,
-                                                grpc_fd* fd);
+  grpc_pollset* (*fd_get_read_notifier_pollset)(grpc_fd* fd);
 
   void (*pollset_init)(grpc_pollset* pollset, gpr_mu** mu);
-  void (*pollset_shutdown)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
-                           grpc_closure* closure);
-  void (*pollset_destroy)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset);
-  grpc_error* (*pollset_work)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+  void (*pollset_shutdown)(grpc_pollset* pollset, grpc_closure* closure);
+  void (*pollset_destroy)(grpc_pollset* pollset);
+  grpc_error* (*pollset_work)(grpc_pollset* pollset,
                               grpc_pollset_worker** worker,
                               grpc_millis deadline);
-  grpc_error* (*pollset_kick)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+  grpc_error* (*pollset_kick)(grpc_pollset* pollset,
                               grpc_pollset_worker* specific_worker);
-  void (*pollset_add_fd)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
-                         struct grpc_fd* fd);
+  void (*pollset_add_fd)(grpc_pollset* pollset, struct grpc_fd* fd);
 
   grpc_pollset_set* (*pollset_set_create)(void);
-  void (*pollset_set_destroy)(grpc_exec_ctx* exec_ctx,
-                              grpc_pollset_set* pollset_set);
-  void (*pollset_set_add_pollset)(grpc_exec_ctx* exec_ctx,
-                                  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_del_pollset)(grpc_exec_ctx* exec_ctx,
-                                  grpc_pollset_set* pollset_set,
+  void (*pollset_set_del_pollset)(grpc_pollset_set* pollset_set,
                                   grpc_pollset* pollset);
-  void (*pollset_set_add_pollset_set)(grpc_exec_ctx* exec_ctx,
-                                      grpc_pollset_set* bag,
+  void (*pollset_set_add_pollset_set)(grpc_pollset_set* bag,
                                       grpc_pollset_set* item);
-  void (*pollset_set_del_pollset_set)(grpc_exec_ctx* exec_ctx,
-                                      grpc_pollset_set* bag,
+  void (*pollset_set_del_pollset_set)(grpc_pollset_set* bag,
                                       grpc_pollset_set* item);
-  void (*pollset_set_add_fd)(grpc_exec_ctx* exec_ctx,
-                             grpc_pollset_set* pollset_set, grpc_fd* fd);
-  void (*pollset_set_del_fd)(grpc_exec_ctx* exec_ctx,
-                             grpc_pollset_set* pollset_set, grpc_fd* fd);
+  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);
 
   void (*shutdown_engine)(void);
 } grpc_event_engine_vtable;
@@ -107,14 +91,14 @@ int grpc_fd_wrapped_fd(grpc_fd* fd);
    Requires: *fd initialized; no outstanding notify_on_read or
    notify_on_write.
    MUST NOT be called with a pollset lock taken */
-void grpc_fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_closure* on_done,
-                    int* release_fd, bool already_closed, const char* reason);
+void grpc_fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
+                    bool already_closed, const char* reason);
 
 /* Has grpc_fd_shutdown been called on an fd? */
 bool grpc_fd_is_shutdown(grpc_fd* fd);
 
 /* Cause any current and future callbacks to fail. */
-void grpc_fd_shutdown(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_error* why);
+void grpc_fd_shutdown(grpc_fd* fd, grpc_error* why);
 
 /* Register read interest, causing read_cb to be called once when fd becomes
    readable, on deadline specified by deadline, or on shutdown triggered by
@@ -129,29 +113,23 @@ void grpc_fd_shutdown(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_error* why);
    underlying platform. This means that users must drain fd in read_cb before
    calling notify_on_read again. Users are also expected to handle spurious
    events, i.e read_cb is called while nothing can be readable from fd  */
-void grpc_fd_notify_on_read(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
-                            grpc_closure* closure);
+void grpc_fd_notify_on_read(grpc_fd* fd, grpc_closure* closure);
 
 /* Exactly the same semantics as above, except based on writable events.  */
-void grpc_fd_notify_on_write(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
-                             grpc_closure* closure);
+void grpc_fd_notify_on_write(grpc_fd* fd, grpc_closure* closure);
 
 /* Return the read notifier pollset from the fd */
-grpc_pollset* grpc_fd_get_read_notifier_pollset(grpc_exec_ctx* exec_ctx,
-                                                grpc_fd* fd);
+grpc_pollset* grpc_fd_get_read_notifier_pollset(grpc_fd* fd);
 
 /* pollset_posix functions */
 
 /* Add an fd to a pollset */
-void grpc_pollset_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
-                         struct grpc_fd* fd);
+void grpc_pollset_add_fd(grpc_pollset* pollset, struct grpc_fd* fd);
 
 /* pollset_set_posix functions */
 
-void grpc_pollset_set_add_fd(grpc_exec_ctx* exec_ctx,
-                             grpc_pollset_set* pollset_set, grpc_fd* fd);
-void grpc_pollset_set_del_fd(grpc_exec_ctx* exec_ctx,
-                             grpc_pollset_set* pollset_set, 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);
 
 /* override to allow tests to hook poll() usage */
 typedef int (*grpc_poll_function_type)(struct pollfd*, nfds_t, int);
@@ -162,8 +140,4 @@ extern grpc_poll_function_type grpc_poll_function;
 void grpc_set_event_engine_test_only(const grpc_event_engine_vtable*);
 const grpc_event_engine_vtable* grpc_get_event_engine_test_only();
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_IOMGR_EV_POSIX_H */

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

@@ -25,39 +25,7 @@
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/profiling/timers.h"
 
-bool grpc_exec_ctx_ready_to_finish(grpc_exec_ctx* exec_ctx) {
-  if ((exec_ctx->flags & GRPC_EXEC_CTX_FLAG_IS_FINISHED) == 0) {
-    if (exec_ctx->check_ready_to_finish(exec_ctx,
-                                        exec_ctx->check_ready_to_finish_arg)) {
-      exec_ctx->flags |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
-      return true;
-    }
-    return false;
-  } else {
-    return true;
-  }
-}
-
-bool grpc_never_ready_to_finish(grpc_exec_ctx* exec_ctx, void* arg_ignored) {
-  return false;
-}
-
-bool grpc_always_ready_to_finish(grpc_exec_ctx* exec_ctx, void* arg_ignored) {
-  return true;
-}
-
-bool grpc_exec_ctx_has_work(grpc_exec_ctx* exec_ctx) {
-  return exec_ctx->active_combiner != nullptr ||
-         !grpc_closure_list_empty(exec_ctx->closure_list);
-}
-
-void grpc_exec_ctx_finish(grpc_exec_ctx* exec_ctx) {
-  exec_ctx->flags |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
-  grpc_exec_ctx_flush(exec_ctx);
-}
-
-static void exec_ctx_run(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
-                         grpc_error* error) {
+static void exec_ctx_run(grpc_closure* closure, grpc_error* error) {
 #ifndef NDEBUG
   closure->scheduled = false;
   if (grpc_trace_closure.enabled()) {
@@ -67,7 +35,7 @@ static void exec_ctx_run(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
             closure->line_initiated);
   }
 #endif
-  closure->cb(exec_ctx, closure->cb_arg, error);
+  closure->cb(closure->cb_arg, error);
 #ifndef NDEBUG
   if (grpc_trace_closure.enabled()) {
     gpr_log(GPR_DEBUG, "closure %p finished", closure);
@@ -76,42 +44,13 @@ static void exec_ctx_run(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
   GRPC_ERROR_UNREF(error);
 }
 
-bool grpc_exec_ctx_flush(grpc_exec_ctx* exec_ctx) {
-  bool did_something = 0;
-  GPR_TIMER_BEGIN("grpc_exec_ctx_flush", 0);
-  for (;;) {
-    if (!grpc_closure_list_empty(exec_ctx->closure_list)) {
-      grpc_closure* c = exec_ctx->closure_list.head;
-      exec_ctx->closure_list.head = exec_ctx->closure_list.tail = nullptr;
-      while (c != nullptr) {
-        grpc_closure* next = c->next_data.next;
-        grpc_error* error = c->error_data.error;
-        did_something = true;
-        exec_ctx_run(exec_ctx, c, error);
-        c = next;
-      }
-    } else if (!grpc_combiner_continue_exec_ctx(exec_ctx)) {
-      break;
-    }
-  }
-  GPR_ASSERT(exec_ctx->active_combiner == nullptr);
-  GPR_TIMER_END("grpc_exec_ctx_flush", 0);
-  return did_something;
-}
-
-static void exec_ctx_sched(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
-                           grpc_error* error) {
-  grpc_closure_list_append(&exec_ctx->closure_list, closure, error);
+static void exec_ctx_sched(grpc_closure* closure, grpc_error* error) {
+  grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure,
+                           error);
 }
 
 static gpr_timespec g_start_time;
 
-void grpc_exec_ctx_global_init(void) {
-  g_start_time = gpr_now(GPR_CLOCK_MONOTONIC);
-}
-
-void grpc_exec_ctx_global_shutdown(void) {}
-
 static gpr_atm timespec_to_atm_round_down(gpr_timespec ts) {
   ts = gpr_time_sub(ts, g_start_time);
   double x =
@@ -131,18 +70,6 @@ static gpr_atm timespec_to_atm_round_up(gpr_timespec ts) {
   return (gpr_atm)x;
 }
 
-grpc_millis grpc_exec_ctx_now(grpc_exec_ctx* exec_ctx) {
-  if (!exec_ctx->now_is_valid) {
-    exec_ctx->now = timespec_to_atm_round_down(gpr_now(GPR_CLOCK_MONOTONIC));
-    exec_ctx->now_is_valid = true;
-  }
-  return exec_ctx->now;
-}
-
-void grpc_exec_ctx_invalidate_now(grpc_exec_ctx* exec_ctx) {
-  exec_ctx->now_is_valid = false;
-}
-
 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
@@ -175,3 +102,44 @@ 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;
+
+namespace grpc_core {
+GPR_TLS_CLASS_DEF(ExecCtx::exec_ctx_);
+
+void ExecCtx::GlobalInit(void) {
+  g_start_time = gpr_now(GPR_CLOCK_MONOTONIC);
+  gpr_tls_init(&exec_ctx_);
+}
+
+bool ExecCtx::Flush() {
+  bool did_something = 0;
+  GPR_TIMER_BEGIN("grpc_exec_ctx_flush", 0);
+  for (;;) {
+    if (!grpc_closure_list_empty(closure_list_)) {
+      grpc_closure* c = closure_list_.head;
+      closure_list_.head = closure_list_.tail = nullptr;
+      while (c != nullptr) {
+        grpc_closure* next = c->next_data.next;
+        grpc_error* error = c->error_data.error;
+        did_something = true;
+        exec_ctx_run(c, error);
+        c = next;
+      }
+    } else if (!grpc_combiner_continue_exec_ctx()) {
+      break;
+    }
+  }
+  GPR_ASSERT(combiner_data_.active_combiner == nullptr);
+  GPR_TIMER_END("grpc_exec_ctx_flush", 0);
+  return did_something;
+}
+
+grpc_millis ExecCtx::Now() {
+  if (!now_is_valid_) {
+    now_ = timespec_to_atm_round_down(gpr_now(GPR_CLOCK_MONOTONIC));
+    now_is_valid_ = true;
+  }
+  return now_;
+}
+
+}  // namespace grpc_core