grpc 1.42.0 → 1.51.0

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/grpc.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_EV
@@ -32,7 +34,6 @@
 #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_poll_posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
@@ -75,44 +76,7 @@ grpc_poll_function_type grpc_poll_function = aix_poll;
 grpc_wakeup_fd grpc_global_wakeup_fd;
 
 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)(
-    bool explicit_request);
-
-struct event_engine_factory {
-  const char* name;
-  event_engine_factory_fn factory;
-};
-namespace {
-
-grpc_poll_function_type real_poll_function;
-
-int phony_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
-  if (timeout == 0) {
-    return real_poll_function(fds, nfds, 0);
-  } else {
-    gpr_log(GPR_ERROR, "Attempted a blocking poll when declared non-polling.");
-    GPR_ASSERT(false);
-    return -1;
-  }
-}
-
-const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
-  if (!explicit_request) {
-    return nullptr;
-  }
-  // return the simplest engine as a phony but also override the poller
-  auto ret = grpc_init_poll_posix(explicit_request);
-  real_poll_function = grpc_poll_function;
-  grpc_poll_function = phony_poll;
-
-  return ret;
-}
-}  // namespace
-
-#define ENGINE_HEAD_CUSTOM "head_custom"
-#define ENGINE_TAIL_CUSTOM "tail_custom"
+static gpr_once g_choose_engine = GPR_ONCE_INIT;
 
 // The global array of event-engine factories. Each entry is a pair with a name
 // and an event-engine generator function (nullptr if there is no generator
@@ -125,13 +89,18 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
 // specific poller that is requested by name in the GRPC_POLL_STRATEGY
 // 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},
-    {"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 const grpc_event_engine_vtable* g_vtables[] = {
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    &grpc_ev_epoll1_posix,
+    &grpc_ev_poll_posix,
+    &grpc_ev_none_posix,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
 };
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
@@ -164,84 +133,73 @@ static bool is(const char* want, const char* have) {
 }
 
 static void try_engine(const char* engine) {
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (g_factories[i].factory != nullptr && is(engine, g_factories[i].name)) {
-      if ((g_event_engine = g_factories[i].factory(
-               0 == strcmp(engine, g_factories[i].name)))) {
-        g_poll_strategy_name = g_factories[i].name;
-        gpr_log(GPR_DEBUG, "Using polling engine: %s", g_factories[i].name);
-        return;
-      }
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_vtables); i++) {
+    if (g_vtables[i] != nullptr && is(engine, g_vtables[i]->name) &&
+        g_vtables[i]->check_engine_available(
+            0 == strcmp(engine, g_vtables[i]->name))) {
+      g_event_engine = g_vtables[i];
+      gpr_log(GPR_DEBUG, "Using polling engine: %s", g_event_engine->name);
+      return;
     }
   }
 }
 
 /* Call this before calling grpc_event_engine_init() */
-void grpc_register_event_engine_factory(const char* name,
-                                        event_engine_factory_fn factory,
+void grpc_register_event_engine_factory(const grpc_event_engine_vtable* vtable,
                                         bool add_at_head) {
-  const char* custom_match =
-      add_at_head ? ENGINE_HEAD_CUSTOM : ENGINE_TAIL_CUSTOM;
+  const grpc_event_engine_vtable** first_null = nullptr;
+  const grpc_event_engine_vtable** last_null = nullptr;
 
   // Overwrite an existing registration if already registered
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (0 == strcmp(name, g_factories[i].name)) {
-      g_factories[i].factory = factory;
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_vtables); i++) {
+    if (g_vtables[i] == nullptr) {
+      if (first_null == nullptr) first_null = &g_vtables[i];
+      last_null = &g_vtables[i];
+    } else if (0 == strcmp(g_vtables[i]->name, vtable->name)) {
+      g_vtables[i] = vtable;
       return;
     }
   }
 
-  // Otherwise fill in an available custom slot
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (0 == strcmp(g_factories[i].name, custom_match)) {
-      g_factories[i].name = name;
-      g_factories[i].factory = factory;
-      return;
-    }
-  }
-
-  // Otherwise fail
-  GPR_ASSERT(false);
+  *(add_at_head ? first_null : last_null) = vtable;
 }
 
 /*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; }
+const char* grpc_get_poll_strategy_name() { return g_event_engine->name; }
 
 void grpc_event_engine_init(void) {
-  grpc_core::UniquePtr<char> value = GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
+  gpr_once_init(&g_choose_engine, []() {
+    grpc_core::UniquePtr<char> value =
+        GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
 
-  char** strings = nullptr;
-  size_t nstrings = 0;
-  split(value.get(), &strings, &nstrings);
+    char** strings = nullptr;
+    size_t nstrings = 0;
+    split(value.get(), &strings, &nstrings);
 
-  for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
-    try_engine(strings[i]);
-  }
+    for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
+      try_engine(strings[i]);
+    }
 
-  for (size_t i = 0; i < nstrings; i++) {
-    gpr_free(strings[i]);
-  }
-  gpr_free(strings);
+    for (size_t i = 0; i < nstrings; i++) {
+      gpr_free(strings[i]);
+    }
+    gpr_free(strings);
 
-  if (g_event_engine == nullptr) {
-    gpr_log(GPR_ERROR, "No event engine could be initialized from %s",
-            value.get());
-    abort();
-  }
+    if (g_event_engine == nullptr) {
+      gpr_log(GPR_ERROR, "No event engine could be initialized from %s",
+              value.get());
+      abort();
+    }
+  });
+  g_event_engine->init_engine();
 }
 
-void grpc_event_engine_shutdown(void) {
-  g_event_engine->shutdown_engine();
-  g_event_engine = nullptr;
-}
+void grpc_event_engine_shutdown(void) { g_event_engine->shutdown_engine(); }
 
 bool grpc_event_engine_can_track_errors(void) {
   /* Only track errors if platform supports errqueue. */
-  if (grpc_core::kernel_supports_errqueue()) {
-    return g_event_engine->can_track_err;
-  }
-  return false;
+  return grpc_core::KernelSupportsErrqueue() && g_event_engine->can_track_err;
 }
 
 bool grpc_event_engine_run_in_background(void) {
@@ -316,13 +274,13 @@ static void pollset_destroy(grpc_pollset* pollset) {
 
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker,
-                                      grpc_millis deadline) {
+                                      grpc_core::Timestamp deadline) {
   GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") begin", pollset,
-                         deadline);
+                         deadline.milliseconds_after_process_epoch());
   grpc_error_handle err =
       g_event_engine->pollset_work(pollset, worker, deadline);
   GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") end", pollset,
-                         deadline);
+                         deadline.milliseconds_after_process_epoch());
   return err;
 }
 

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

@@ -66,7 +66,7 @@ typedef struct grpc_event_engine_vtable {
   void (*pollset_destroy)(grpc_pollset* pollset);
   grpc_error_handle (*pollset_work)(grpc_pollset* pollset,
                                     grpc_pollset_worker** worker,
-                                    grpc_millis deadline);
+                                    grpc_core::Timestamp deadline);
   grpc_error_handle (*pollset_kick)(grpc_pollset* pollset,
                                     grpc_pollset_worker* specific_worker);
   void (*pollset_add_fd)(grpc_pollset* pollset, struct grpc_fd* fd);
@@ -85,6 +85,9 @@ typedef struct grpc_event_engine_vtable {
   void (*pollset_set_del_fd)(grpc_pollset_set* pollset_set, grpc_fd* fd);
 
   bool (*is_any_background_poller_thread)(void);
+  const char* name;
+  bool (*check_engine_available)(bool explicit_request);
+  void (*init_engine)();
   void (*shutdown_background_closure)(void);
   void (*shutdown_engine)(void);
   bool (*add_closure_to_background_poller)(grpc_closure* closure,
@@ -92,9 +95,8 @@ typedef struct grpc_event_engine_vtable {
 } grpc_event_engine_vtable;
 
 /* register a new event engine factory */
-void grpc_register_event_engine_factory(
-    const char* name, const grpc_event_engine_vtable* (*factory)(bool),
-    bool add_at_head);
+void grpc_register_event_engine_factory(const grpc_event_engine_vtable* vtable,
+                                        bool add_at_head);
 
 void grpc_event_engine_init(void);
 void grpc_event_engine_shutdown(void);

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

@@ -25,9 +25,8 @@
 
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/profiling/timers.h"
 
-static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
+static void exec_ctx_run(grpc_closure* closure) {
 #ifndef NDEBUG
   closure->scheduled = false;
   if (grpc_trace_closure.enabled()) {
@@ -37,123 +36,37 @@ static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
             closure->line_initiated);
   }
 #endif
-  closure->cb(closure->cb_arg, error);
+  grpc_error_handle error =
+      grpc_core::internal::StatusMoveFromHeapPtr(closure->error_data.error);
+  closure->error_data.error = 0;
+  closure->cb(closure->cb_arg, std::move(error));
 #ifndef NDEBUG
   if (grpc_trace_closure.enabled()) {
     gpr_log(GPR_DEBUG, "closure %p finished", closure);
   }
 #endif
-  GRPC_ERROR_UNREF(error);
 }
 
-static void exec_ctx_sched(grpc_closure* closure, grpc_error_handle error) {
-  grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure,
-                           error);
-}
-
-static gpr_timespec g_start_time;
-static gpr_cycle_counter g_start_cycle;
-
-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;
-  if (x > static_cast<double>(GRPC_MILLIS_INF_FUTURE)) {
-    return GRPC_MILLIS_INF_FUTURE;
-  }
-  return static_cast<grpc_millis>(x);
-}
-
-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) /
-                 static_cast<double>(GPR_NS_PER_SEC);
-  if (x < 0) return 0;
-  if (x > static_cast<double>(GRPC_MILLIS_INF_FUTURE)) {
-    return GRPC_MILLIS_INF_FUTURE;
-  }
-  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
-  // while gpr_time_from_millis always takes an int64_t.
-  if (millis == GRPC_MILLIS_INF_FUTURE) {
-    return gpr_inf_future(clock_type);
-  }
-  if (millis == GRPC_MILLIS_INF_PAST) {
-    return gpr_inf_past(clock_type);
-  }
-
-  if (clock_type == GPR_TIMESPAN) {
-    return gpr_time_from_millis(millis, GPR_TIMESPAN);
-  }
-  return gpr_time_add(gpr_convert_clock_type(g_start_time, clock_type),
-                      gpr_time_from_millis(millis, GPR_TIMESPAN));
-}
-
-grpc_millis grpc_timespec_to_millis_round_down(gpr_timespec ts) {
-  return timespec_to_millis_round_down(
-      gpr_convert_clock_type(ts, g_start_time.clock_type));
-}
-
-grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec ts) {
-  return timespec_to_millis_round_up(
-      gpr_convert_clock_type(ts, g_start_time.clock_type));
-}
-
-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));
+static void exec_ctx_sched(grpc_closure* closure) {
+  grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure);
 }
 
 namespace grpc_core {
-GPR_THREAD_LOCAL(ExecCtx*) ExecCtx::exec_ctx_;
-GPR_THREAD_LOCAL(ApplicationCallbackExecCtx*)
-ApplicationCallbackExecCtx::callback_exec_ctx_;
-
-// WARNING: for testing purposes only!
-void ExecCtx::TestOnlyGlobalInit(gpr_timespec new_val) {
-  g_start_time = 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;
-}
+thread_local ExecCtx* ExecCtx::exec_ctx_;
+thread_local ApplicationCallbackExecCtx*
+    ApplicationCallbackExecCtx::callback_exec_ctx_;
 
 bool ExecCtx::Flush() {
   bool did_something = false;
-  GPR_TIMER_SCOPE("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_handle error = c->error_data.error;
         did_something = true;
-        exec_ctx_run(c, error);
+        exec_ctx_run(c);
         c = next;
       }
     } else if (!grpc_combiner_continue_exec_ctx()) {
@@ -164,19 +77,10 @@ bool ExecCtx::Flush() {
   return did_something;
 }
 
-grpc_millis ExecCtx::Now() {
-  if (!now_is_valid_) {
-    now_ = timespec_to_millis_round_down(gpr_now(GPR_CLOCK_MONOTONIC));
-    now_is_valid_ = true;
-  }
-  return now_;
-}
-
 void ExecCtx::Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error) {
   (void)location;
   if (closure == nullptr) {
-    GRPC_ERROR_UNREF(error);
     return;
   }
 #ifndef NDEBUG
@@ -195,7 +99,8 @@ void ExecCtx::Run(const DebugLocation& location, grpc_closure* closure,
   closure->run = false;
   GPR_ASSERT(closure->cb != nullptr);
 #endif
-  exec_ctx_sched(closure, error);
+  closure->error_data.error = internal::StatusAllocHeapPtr(error);
+  exec_ctx_sched(closure);
 }
 
 void ExecCtx::RunList(const DebugLocation& location, grpc_closure_list* list) {
@@ -218,7 +123,7 @@ void ExecCtx::RunList(const DebugLocation& location, grpc_closure_list* list) {
     c->run = false;
     GPR_ASSERT(c->cb != nullptr);
 #endif
-    exec_ctx_sched(c, c->error_data.error);
+    exec_ctx_sched(c);
     c = next;
   }
   list->head = list->tail = nullptr;

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

@@ -23,22 +23,18 @@
 
 #include <limits>
 
+#include <grpc/impl/codegen/gpr_types.h>
 #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/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 
-typedef int64_t grpc_millis;
-
-#define GRPC_MILLIS_INF_FUTURE INT64_MAX
-#define GRPC_MILLIS_INF_PAST INT64_MIN
-
 /** 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;
@@ -57,12 +53,6 @@ typedef struct grpc_combiner grpc_combiner;
    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 ts);
-grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec ts);
-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.
@@ -73,10 +63,10 @@ class Combiner;
  *  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 :
  *
- *  grpc_core::ExecCtx exec_ctx;
+ *  ExecCtx exec_ctx;
  *
  *  Access the created ExecCtx instance using :
- *  grpc_core::ExecCtx::Get()
+ *  ExecCtx::Get()
  *
  *  Specific responsibilities (this may grow in the future):
  *  - track a list of core work that needs to be delayed until the base of the
@@ -90,7 +80,7 @@ class Combiner;
  *  - Instance of this must ALWAYS be constructed on the stack, never
  *    heap allocated.
  *  - Do not pass exec_ctx as a parameter to a function. Always access it using
- *    grpc_core::ExecCtx::Get().
+ *    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.
@@ -108,14 +98,14 @@ class ExecCtx {
   /** Default Constructor */
 
   ExecCtx() : flags_(GRPC_EXEC_CTX_FLAG_IS_FINISHED) {
-    grpc_core::Fork::IncExecCtxCount();
+    Fork::IncExecCtxCount();
     Set(this);
   }
 
   /** Parameterised Constructor */
   explicit ExecCtx(uintptr_t fl) : flags_(fl) {
     if (!(GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
-      grpc_core::Fork::IncExecCtxCount();
+      Fork::IncExecCtxCount();
     }
     Set(this);
   }
@@ -126,7 +116,7 @@ class ExecCtx {
     Flush();
     Set(last_exec_ctx_);
     if (!(GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
-      grpc_core::Fork::DecExecCtxCount();
+      Fork::DecExecCtxCount();
     }
   }
 
@@ -185,44 +175,18 @@ class ExecCtx {
     }
   }
 
-  /** Returns the stored current time relative to start if valid,
-   *  otherwise refreshes the stored time, sets it valid and returns the new
-   *  value.
-   */
-  grpc_millis Now();
-
-  /** Invalidates the stored time value. A new time value will be set on calling
-   *  Now().
-   */
-  void InvalidateNow() { now_is_valid_ = false; }
-
-  /** To be used only by shutdown code in iomgr */
+  Timestamp Now() { return Timestamp::Now(); }
+  void InvalidateNow() { time_cache_.InvalidateCache(); }
   void SetNowIomgrShutdown() {
-    now_ = GRPC_MILLIS_INF_FUTURE;
-    now_is_valid_ = true;
-  }
-
-  /** To be used only for testing.
-   *  Sets the now value.
-   */
-  void TestOnlySetNow(grpc_millis new_val) {
-    now_ = new_val;
-    now_is_valid_ = true;
+    // We get to do a test only set now on this path just because iomgr
+    // is getting removed and no point adding more interfaces for it.
+    time_cache_.TestOnlySetNow(Timestamp::InfFuture());
   }
-
-  static void TestOnlyGlobalInit(gpr_timespec new_val);
-
-  /** Global initialization for ExecCtx. Called by iomgr. */
-  static void GlobalInit(void);
-
-  /** Global shutdown for ExecCtx. Called by iomgr. */
-  static void GlobalShutdown(void) {}
+  void TestOnlySetNow(Timestamp now) { time_cache_.TestOnlySetNow(now); }
 
   /** Gets pointer to current exec_ctx. */
   static ExecCtx* Get() { return exec_ctx_; }
 
-  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
-
   static void Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error);
 
@@ -237,6 +201,7 @@ class ExecCtx {
 
  private:
   /** Set exec_ctx_ to exec_ctx. */
+  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
 
   grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
   CombinerData combiner_data_ = {nullptr, nullptr};
@@ -244,10 +209,8 @@ class ExecCtx {
 
   unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
 
-  bool now_is_valid_ = false;
-  grpc_millis now_ = 0;
-
-  static GPR_THREAD_LOCAL(ExecCtx*) exec_ctx_;
+  ScopedTimeCache time_cache_;
+  static thread_local ExecCtx* exec_ctx_;
   ExecCtx* last_exec_ctx_ = Get();
 };
 
@@ -276,7 +239,7 @@ class ExecCtx {
  *  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 .
+ *  enqueued using ApplicationCallbackExecCtx::Enqueue .
  *
  *  CONVENTIONS:
  *  - Instances of this must ALWAYS be constructed on the stack, never
@@ -289,8 +252,8 @@ class ExecCtx {
  *  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;
+ *  ApplicationCallbackExecCtx callback_exec_ctx;
+ *  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
@@ -320,7 +283,7 @@ class ApplicationCallbackExecCtx {
       }
       callback_exec_ctx_ = nullptr;
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
-        grpc_core::Fork::DecExecCtxCount();
+        Fork::DecExecCtxCount();
       }
     } else {
       GPR_DEBUG_ASSERT(head_ == nullptr);
@@ -335,7 +298,7 @@ class ApplicationCallbackExecCtx {
   static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
     if (Get() == nullptr) {
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags)) {
-        grpc_core::Fork::IncExecCtxCount();
+        Fork::IncExecCtxCount();
       }
       callback_exec_ctx_ = exec_ctx;
     }
@@ -356,20 +319,15 @@ class ApplicationCallbackExecCtx {
     ctx->tail_ = functor;
   }
 
-  /** Global initialization for ApplicationCallbackExecCtx. Called by init. */
-  static void GlobalInit(void) {}
-
-  /** Global shutdown for ApplicationCallbackExecCtx. Called by init. */
-  static void GlobalShutdown(void) {}
-
   static bool Available() { return Get() != nullptr; }
 
  private:
   uintptr_t flags_{0u};
   grpc_completion_queue_functor* head_{nullptr};
   grpc_completion_queue_functor* tail_{nullptr};
-  static GPR_THREAD_LOCAL(ApplicationCallbackExecCtx*) callback_exec_ctx_;
+  static thread_local ApplicationCallbackExecCtx* callback_exec_ctx_;
 };
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXEC_CTX_H */