grpc 1.7.3 → 1.8.0

data/src/core/lib/surface/channel.h

@@ -23,13 +23,17 @@
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
-grpc_channel *grpc_channel_create(grpc_exec_ctx *exec_ctx, const char *target,
-                                  const grpc_channel_args *args,
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+grpc_channel* grpc_channel_create(grpc_exec_ctx* exec_ctx, const char* target,
+                                  const grpc_channel_args* args,
                                   grpc_channel_stack_type channel_stack_type,
-                                  grpc_transport *optional_transport);
+                                  grpc_transport* optional_transport);
 
-grpc_channel *grpc_channel_create_with_builder(
-    grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
+grpc_channel* grpc_channel_create_with_builder(
+    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
     grpc_channel_stack_type channel_stack_type);
 
 /** Create a call given a grpc_channel, in order to call \a method.
@@ -40,37 +44,37 @@ grpc_channel *grpc_channel_create_with_builder(
     non-NULL, it must be a server-side call. It will be used to propagate
     properties from the server call to this new client call, depending on the
     value of \a propagation_mask (see propagation_bits.h for possible values) */
-grpc_call *grpc_channel_create_pollset_set_call(
-    grpc_exec_ctx *exec_ctx, grpc_channel *channel, grpc_call *parent_call,
-    uint32_t propagation_mask, grpc_pollset_set *pollset_set, grpc_slice method,
-    const grpc_slice *host, gpr_timespec deadline, void *reserved);
+grpc_call* grpc_channel_create_pollset_set_call(
+    grpc_exec_ctx* exec_ctx, grpc_channel* channel, grpc_call* parent_call,
+    uint32_t propagation_mask, grpc_pollset_set* pollset_set, grpc_slice method,
+    const grpc_slice* host, grpc_millis deadline, void* reserved);
 
 /** Get a (borrowed) pointer to this channels underlying channel stack */
-grpc_channel_stack *grpc_channel_get_channel_stack(grpc_channel *channel);
+grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel);
 
 /** Get a grpc_mdelem of grpc-status: X where X is the numeric value of
     status_code.
 
     The returned elem is owned by the caller. */
-grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_exec_ctx *exec_ctx,
-                                                grpc_channel *channel,
+grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_exec_ctx* exec_ctx,
+                                                grpc_channel* channel,
                                                 int status_code);
 
-size_t grpc_channel_get_call_size_estimate(grpc_channel *channel);
-void grpc_channel_update_call_size_estimate(grpc_channel *channel, size_t size);
+size_t grpc_channel_get_call_size_estimate(grpc_channel* channel);
+void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size);
 
 #ifndef NDEBUG
-void grpc_channel_internal_ref(grpc_channel *channel, const char *reason);
-void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx, grpc_channel *channel,
-                                 const char *reason);
+void grpc_channel_internal_ref(grpc_channel* channel, const char* reason);
+void grpc_channel_internal_unref(grpc_exec_ctx* exec_ctx, grpc_channel* channel,
+                                 const char* reason);
 #define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
   grpc_channel_internal_ref(channel, reason)
 #define GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, channel, reason) \
   grpc_channel_internal_unref(exec_ctx, channel, reason)
 #else
-void grpc_channel_internal_ref(grpc_channel *channel);
-void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel *channel);
+void grpc_channel_internal_ref(grpc_channel* channel);
+void grpc_channel_internal_unref(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel* channel);
 #define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
   grpc_channel_internal_ref(channel)
 #define GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, channel, reason) \
@@ -79,6 +83,10 @@ void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx,
 
 /** Return the channel's compression options. */
 grpc_compression_options grpc_channel_compression_options(
-    const grpc_channel *channel);
+    const grpc_channel* channel);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SURFACE_CHANNEL_H */

data/src/core/lib/surface/{channel_init.c → channel_init.cc}

@@ -23,13 +23,13 @@
 
 typedef struct stage_slot {
   grpc_channel_init_stage fn;
-  void *arg;
+  void* arg;
   int priority;
   size_t insertion_order;
 } stage_slot;
 
 typedef struct stage_slots {
-  stage_slot *slots;
+  stage_slot* slots;
   size_t num_slots;
   size_t cap_slots;
 } stage_slots;
@@ -39,7 +39,7 @@ static bool g_finalized;
 
 void grpc_channel_init_init(void) {
   for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
-    g_slots[i].slots = NULL;
+    g_slots[i].slots = nullptr;
     g_slots[i].num_slots = 0;
     g_slots[i].cap_slots = 0;
   }
@@ -49,24 +49,24 @@ void grpc_channel_init_init(void) {
 void grpc_channel_init_register_stage(grpc_channel_stack_type type,
                                       int priority,
                                       grpc_channel_init_stage stage,
-                                      void *stage_arg) {
+                                      void* stage_arg) {
   GPR_ASSERT(!g_finalized);
   if (g_slots[type].cap_slots == g_slots[type].num_slots) {
     g_slots[type].cap_slots = GPR_MAX(8, 3 * g_slots[type].cap_slots / 2);
-    g_slots[type].slots = (stage_slot *)gpr_realloc(
+    g_slots[type].slots = (stage_slot*)gpr_realloc(
         g_slots[type].slots,
         g_slots[type].cap_slots * sizeof(*g_slots[type].slots));
   }
-  stage_slot *s = &g_slots[type].slots[g_slots[type].num_slots++];
+  stage_slot* s = &g_slots[type].slots[g_slots[type].num_slots++];
   s->insertion_order = g_slots[type].num_slots;
   s->priority = priority;
   s->fn = stage;
   s->arg = stage_arg;
 }
 
-static int compare_slots(const void *a, const void *b) {
-  const stage_slot *sa = (const stage_slot *)a;
-  const stage_slot *sb = (const stage_slot *)b;
+static int compare_slots(const void* a, const void* b) {
+  const stage_slot* sa = (const stage_slot*)a;
+  const stage_slot* sb = (const stage_slot*)b;
 
   int c = GPR_ICMP(sa->priority, sb->priority);
   if (c != 0) return c;
@@ -85,12 +85,12 @@ void grpc_channel_init_finalize(void) {
 void grpc_channel_init_shutdown(void) {
   for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
     gpr_free(g_slots[i].slots);
-    g_slots[i].slots = (stage_slot *)(void *)(uintptr_t)0xdeadbeef;
+    g_slots[i].slots = (stage_slot*)(void*)(uintptr_t)0xdeadbeef;
   }
 }
 
-bool grpc_channel_init_create_stack(grpc_exec_ctx *exec_ctx,
-                                    grpc_channel_stack_builder *builder,
+bool grpc_channel_init_create_stack(grpc_exec_ctx* exec_ctx,
+                                    grpc_channel_stack_builder* builder,
                                     grpc_channel_stack_type type) {
   GPR_ASSERT(g_finalized);
 
@@ -98,7 +98,7 @@ bool grpc_channel_init_create_stack(grpc_exec_ctx *exec_ctx,
                                       grpc_channel_stack_type_string(type));
 
   for (size_t i = 0; i < g_slots[type].num_slots; i++) {
-    const stage_slot *slot = &g_slots[type].slots[i];
+    const stage_slot* slot = &g_slots[type].slots[i];
     if (!slot->fn(exec_ctx, builder, slot->arg)) {
       return false;
     }

data/src/core/lib/surface/channel_init.h

@@ -36,9 +36,9 @@ extern "C" {
 
 /// One stage of mutation: call functions against \a builder to influence the
 /// finally constructed channel stack
-typedef bool (*grpc_channel_init_stage)(grpc_exec_ctx *exec_ctx,
-                                        grpc_channel_stack_builder *builder,
-                                        void *arg);
+typedef bool (*grpc_channel_init_stage)(grpc_exec_ctx* exec_ctx,
+                                        grpc_channel_stack_builder* builder,
+                                        void* arg);
 
 /// Global initialization of the system
 void grpc_channel_init_init(void);
@@ -51,7 +51,7 @@ void grpc_channel_init_init(void);
 void grpc_channel_init_register_stage(grpc_channel_stack_type type,
                                       int priority,
                                       grpc_channel_init_stage stage_fn,
-                                      void *stage_arg);
+                                      void* stage_arg);
 
 /// Finalize registration. No more calls to grpc_channel_init_register_stage are
 /// allowed.
@@ -70,8 +70,8 @@ void grpc_channel_init_shutdown(void);
 /// \a optional_transport is either NULL or a constructed transport object
 /// Returns a pointer to the base of the memory allocated (the actual channel
 /// stack object will be prefix_bytes past that pointer)
-bool grpc_channel_init_create_stack(grpc_exec_ctx *exec_ctx,
-                                    grpc_channel_stack_builder *builder,
+bool grpc_channel_init_create_stack(grpc_exec_ctx* exec_ctx,
+                                    grpc_channel_stack_builder* builder,
                                     grpc_channel_stack_type type);
 
 #ifdef __cplusplus

data/src/core/lib/surface/{channel_ping.c → channel_ping.cc}

@@ -28,32 +28,32 @@
 
 typedef struct {
   grpc_closure closure;
-  void *tag;
-  grpc_completion_queue *cq;
+  void* tag;
+  grpc_completion_queue* cq;
   grpc_cq_completion completion_storage;
 } ping_result;
 
-static void ping_destroy(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_cq_completion *storage) {
+static void ping_destroy(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_cq_completion* storage) {
   gpr_free(arg);
 }
 
-static void ping_done(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  ping_result *pr = (ping_result *)arg;
+static void ping_done(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  ping_result* pr = (ping_result*)arg;
   grpc_cq_end_op(exec_ctx, pr->cq, pr->tag, GRPC_ERROR_REF(error), ping_destroy,
                  pr, &pr->completion_storage);
 }
 
-void grpc_channel_ping(grpc_channel *channel, grpc_completion_queue *cq,
-                       void *tag, void *reserved) {
+void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq,
+                       void* tag, void* reserved) {
   GRPC_API_TRACE("grpc_channel_ping(channel=%p, cq=%p, tag=%p, reserved=%p)", 4,
                  (channel, cq, tag, reserved));
-  grpc_transport_op *op = grpc_make_transport_op(NULL);
-  ping_result *pr = (ping_result *)gpr_malloc(sizeof(*pr));
-  grpc_channel_element *top_elem =
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  ping_result* pr = (ping_result*)gpr_malloc(sizeof(*pr));
+  grpc_channel_element* top_elem =
       grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GPR_ASSERT(reserved == NULL);
+  GPR_ASSERT(reserved == nullptr);
   pr->tag = tag;
   pr->cq = cq;
   GRPC_CLOSURE_INIT(&pr->closure, ping_done, pr, grpc_schedule_on_exec_ctx);

data/src/core/lib/surface/{channel_stack_type.c → channel_stack_type.cc}

@@ -38,7 +38,7 @@ bool grpc_channel_stack_type_is_client(grpc_channel_stack_type type) {
   GPR_UNREACHABLE_CODE(return true;);
 }
 
-const char *grpc_channel_stack_type_string(grpc_channel_stack_type type) {
+const char* grpc_channel_stack_type_string(grpc_channel_stack_type type) {
   switch (type) {
     case GRPC_CLIENT_CHANNEL:
       return "CLIENT_CHANNEL";

data/src/core/lib/surface/channel_stack_type.h

@@ -21,6 +21,10 @@
 
 #include <stdbool.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef enum {
   // normal top-half client channel with load-balancing, connection management
   GRPC_CLIENT_CHANNEL,
@@ -40,6 +44,10 @@ typedef enum {
 
 bool grpc_channel_stack_type_is_client(grpc_channel_stack_type type);
 
-const char *grpc_channel_stack_type_string(grpc_channel_stack_type type);
+const char* grpc_channel_stack_type_string(grpc_channel_stack_type type);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SURFACE_CHANNEL_STACK_TYPE_H */

data/src/core/lib/surface/{completion_queue.c → completion_queue.cc}

@@ -15,8 +15,11 @@
  * limitations under the License.
  *
  */
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/surface/completion_queue.h"
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -25,6 +28,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
+#include <grpc/support/tls.h>
 
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/iomgr/pollset.h"
@@ -36,75 +40,76 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/event_string.h"
 
-grpc_tracer_flag grpc_trace_operation_failures =
-    GRPC_TRACER_INITIALIZER(false, "op_failure");
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_pending_tags =
-    GRPC_TRACER_INITIALIZER(false, "pending_tags");
-grpc_tracer_flag grpc_trace_cq_refcount =
-    GRPC_TRACER_INITIALIZER(false, "cq_refcount");
-#endif
+grpc_core::TraceFlag grpc_trace_operation_failures(false, "op_failure");
+grpc_core::DebugOnlyTraceFlag grpc_trace_pending_tags(false, "pending_tags");
+grpc_core::DebugOnlyTraceFlag grpc_trace_cq_refcount(false, "cq_refcount");
+
+// Specifies a cq thread local cache.
+// The first event that occurs on a thread
+// with a cq cache will go into that cache, and
+// will only be returned on the thread that initialized the cache.
+// NOTE: Only one event will ever be cached.
+GPR_TLS_DECL(g_cached_event);
+GPR_TLS_DECL(g_cached_cq);
 
 typedef struct {
-  grpc_pollset_worker **worker;
-  void *tag;
+  grpc_pollset_worker** worker;
+  void* tag;
 } plucker;
 
 typedef struct {
   bool can_get_pollset;
   bool can_listen;
   size_t (*size)(void);
-  void (*init)(grpc_pollset *pollset, gpr_mu **mu);
-  grpc_error *(*kick)(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                      grpc_pollset_worker *specific_worker);
-  grpc_error *(*work)(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                      grpc_pollset_worker **worker, gpr_timespec now,
-                      gpr_timespec deadline);
-  void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                   grpc_closure *closure);
-  void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset);
+  void (*init)(grpc_pollset* pollset, gpr_mu** mu);
+  grpc_error* (*kick)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                      grpc_pollset_worker* specific_worker);
+  grpc_error* (*work)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                      grpc_pollset_worker** worker, grpc_millis deadline);
+  void (*shutdown)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                   grpc_closure* closure);
+  void (*destroy)(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset);
 } cq_poller_vtable;
 
 typedef struct non_polling_worker {
   gpr_cv cv;
   bool kicked;
-  struct non_polling_worker *next;
-  struct non_polling_worker *prev;
+  struct non_polling_worker* next;
+  struct non_polling_worker* prev;
 } non_polling_worker;
 
 typedef struct {
   gpr_mu mu;
-  non_polling_worker *root;
-  grpc_closure *shutdown;
+  non_polling_worker* root;
+  grpc_closure* shutdown;
 } non_polling_poller;
 
 static size_t non_polling_poller_size(void) {
   return sizeof(non_polling_poller);
 }
 
-static void non_polling_poller_init(grpc_pollset *pollset, gpr_mu **mu) {
-  non_polling_poller *npp = (non_polling_poller *)pollset;
+static void non_polling_poller_init(grpc_pollset* pollset, gpr_mu** mu) {
+  non_polling_poller* npp = (non_polling_poller*)pollset;
   gpr_mu_init(&npp->mu);
   *mu = &npp->mu;
 }
 
-static void non_polling_poller_destroy(grpc_exec_ctx *exec_ctx,
-                                       grpc_pollset *pollset) {
-  non_polling_poller *npp = (non_polling_poller *)pollset;
+static void non_polling_poller_destroy(grpc_exec_ctx* exec_ctx,
+                                       grpc_pollset* pollset) {
+  non_polling_poller* npp = (non_polling_poller*)pollset;
   gpr_mu_destroy(&npp->mu);
 }
 
-static grpc_error *non_polling_poller_work(grpc_exec_ctx *exec_ctx,
-                                           grpc_pollset *pollset,
-                                           grpc_pollset_worker **worker,
-                                           gpr_timespec now,
-                                           gpr_timespec deadline) {
-  non_polling_poller *npp = (non_polling_poller *)pollset;
+static grpc_error* non_polling_poller_work(grpc_exec_ctx* exec_ctx,
+                                           grpc_pollset* pollset,
+                                           grpc_pollset_worker** worker,
+                                           grpc_millis deadline) {
+  non_polling_poller* npp = (non_polling_poller*)pollset;
   if (npp->shutdown) return GRPC_ERROR_NONE;
   non_polling_worker w;
   gpr_cv_init(&w.cv);
-  if (worker != NULL) *worker = (grpc_pollset_worker *)&w;
-  if (npp->root == NULL) {
+  if (worker != nullptr) *worker = (grpc_pollset_worker*)&w;
+  if (npp->root == nullptr) {
     npp->root = w.next = w.prev = &w;
   } else {
     w.next = npp->root;
@@ -112,31 +117,36 @@ static grpc_error *non_polling_poller_work(grpc_exec_ctx *exec_ctx,
     w.next->prev = w.prev->next = &w;
   }
   w.kicked = false;
-  while (!npp->shutdown && !w.kicked && !gpr_cv_wait(&w.cv, &npp->mu, deadline))
+  gpr_timespec deadline_ts =
+      grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME);
+  while (!npp->shutdown && !w.kicked &&
+         !gpr_cv_wait(&w.cv, &npp->mu, deadline_ts))
     ;
+  grpc_exec_ctx_invalidate_now(exec_ctx);
   if (&w == npp->root) {
     npp->root = w.next;
     if (&w == npp->root) {
       if (npp->shutdown) {
         GRPC_CLOSURE_SCHED(exec_ctx, npp->shutdown, GRPC_ERROR_NONE);
       }
-      npp->root = NULL;
+      npp->root = nullptr;
     }
   }
   w.next->prev = w.prev;
   w.prev->next = w.next;
   gpr_cv_destroy(&w.cv);
-  if (worker != NULL) *worker = NULL;
+  if (worker != nullptr) *worker = nullptr;
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error *non_polling_poller_kick(
-    grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-    grpc_pollset_worker *specific_worker) {
-  non_polling_poller *p = (non_polling_poller *)pollset;
-  if (specific_worker == NULL) specific_worker = (grpc_pollset_worker *)p->root;
-  if (specific_worker != NULL) {
-    non_polling_worker *w = (non_polling_worker *)specific_worker;
+static grpc_error* non_polling_poller_kick(
+    grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+    grpc_pollset_worker* specific_worker) {
+  non_polling_poller* p = (non_polling_poller*)pollset;
+  if (specific_worker == nullptr)
+    specific_worker = (grpc_pollset_worker*)p->root;
+  if (specific_worker != nullptr) {
+    non_polling_worker* w = (non_polling_worker*)specific_worker;
     if (!w->kicked) {
       w->kicked = true;
       gpr_cv_signal(&w->cv);
@@ -145,16 +155,16 @@ static grpc_error *non_polling_poller_kick(
   return GRPC_ERROR_NONE;
 }
 
-static void non_polling_poller_shutdown(grpc_exec_ctx *exec_ctx,
-                                        grpc_pollset *pollset,
-                                        grpc_closure *closure) {
-  non_polling_poller *p = (non_polling_poller *)pollset;
-  GPR_ASSERT(closure != NULL);
+static void non_polling_poller_shutdown(grpc_exec_ctx* exec_ctx,
+                                        grpc_pollset* pollset,
+                                        grpc_closure* closure) {
+  non_polling_poller* p = (non_polling_poller*)pollset;
+  GPR_ASSERT(closure != nullptr);
   p->shutdown = closure;
-  if (p->root == NULL) {
+  if (p->root == nullptr) {
     GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_ERROR_NONE);
   } else {
-    non_polling_worker *w = p->root;
+    non_polling_worker* w = p->root;
     do {
       gpr_cv_signal(&w->cv);
       w = w->next;
@@ -164,50 +174,33 @@ static void non_polling_poller_shutdown(grpc_exec_ctx *exec_ctx,
 
 static const cq_poller_vtable g_poller_vtable_by_poller_type[] = {
     /* GRPC_CQ_DEFAULT_POLLING */
-    {.can_get_pollset = true,
-     .can_listen = true,
-     .size = grpc_pollset_size,
-     .init = grpc_pollset_init,
-     .kick = grpc_pollset_kick,
-     .work = grpc_pollset_work,
-     .shutdown = grpc_pollset_shutdown,
-     .destroy = grpc_pollset_destroy},
+    {true, true, grpc_pollset_size, grpc_pollset_init, grpc_pollset_kick,
+     grpc_pollset_work, grpc_pollset_shutdown, grpc_pollset_destroy},
     /* GRPC_CQ_NON_LISTENING */
-    {.can_get_pollset = true,
-     .can_listen = false,
-     .size = grpc_pollset_size,
-     .init = grpc_pollset_init,
-     .kick = grpc_pollset_kick,
-     .work = grpc_pollset_work,
-     .shutdown = grpc_pollset_shutdown,
-     .destroy = grpc_pollset_destroy},
+    {true, false, grpc_pollset_size, grpc_pollset_init, grpc_pollset_kick,
+     grpc_pollset_work, grpc_pollset_shutdown, grpc_pollset_destroy},
     /* GRPC_CQ_NON_POLLING */
-    {.can_get_pollset = false,
-     .can_listen = false,
-     .size = non_polling_poller_size,
-     .init = non_polling_poller_init,
-     .kick = non_polling_poller_kick,
-     .work = non_polling_poller_work,
-     .shutdown = non_polling_poller_shutdown,
-     .destroy = non_polling_poller_destroy},
+    {false, false, non_polling_poller_size, non_polling_poller_init,
+     non_polling_poller_kick, non_polling_poller_work,
+     non_polling_poller_shutdown, non_polling_poller_destroy},
 };
 
 typedef struct cq_vtable {
   grpc_cq_completion_type cq_completion_type;
   size_t data_size;
-  void (*init)(void *data);
-  void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_completion_queue *cq);
-  void (*destroy)(void *data);
-  bool (*begin_op)(grpc_completion_queue *cq, void *tag);
-  void (*end_op)(grpc_exec_ctx *exec_ctx, grpc_completion_queue *cq, void *tag,
-                 grpc_error *error,
-                 void (*done)(grpc_exec_ctx *exec_ctx, void *done_arg,
-                              grpc_cq_completion *storage),
-                 void *done_arg, grpc_cq_completion *storage);
-  grpc_event (*next)(grpc_completion_queue *cq, gpr_timespec deadline,
-                     void *reserved);
-  grpc_event (*pluck)(grpc_completion_queue *cq, void *tag,
-                      gpr_timespec deadline, void *reserved);
+  void (*init)(void* data);
+  void (*shutdown)(grpc_exec_ctx* exec_ctx, grpc_completion_queue* cq);
+  void (*destroy)(void* data);
+  bool (*begin_op)(grpc_completion_queue* cq, void* tag);
+  void (*end_op)(grpc_exec_ctx* exec_ctx, grpc_completion_queue* cq, void* tag,
+                 grpc_error* error,
+                 void (*done)(grpc_exec_ctx* exec_ctx, void* done_arg,
+                              grpc_cq_completion* storage),
+                 void* done_arg, grpc_cq_completion* storage);
+  grpc_event (*next)(grpc_completion_queue* cq, gpr_timespec deadline,
+                     void* reserved);
+  grpc_event (*pluck)(grpc_completion_queue* cq, void* tag,
+                      gpr_timespec deadline, void* reserved);
 } cq_vtable;
 
 /* Queue that holds the cq_completion_events. Internally uses gpr_mpscq queue
@@ -244,7 +237,7 @@ typedef struct cq_next_data {
 typedef struct cq_pluck_data {
   /** Completed events for completion-queues of type GRPC_CQ_PLUCK */
   grpc_cq_completion completed_head;
-  grpc_cq_completion *completed_tail;
+  grpc_cq_completion* completed_tail;
 
   /** Number of pending events (+1 if we're not shutdown) */
   gpr_atm pending_events;
@@ -271,13 +264,13 @@ struct grpc_completion_queue {
   /** Once owning_refs drops to zero, we will destroy the cq */
   gpr_refcount owning_refs;
 
-  gpr_mu *mu;
+  gpr_mu* mu;
 
-  const cq_vtable *vtable;
-  const cq_poller_vtable *poller_vtable;
+  const cq_vtable* vtable;
+  const cq_poller_vtable* poller_vtable;
 
 #ifndef NDEBUG
-  void **outstanding_tags;
+  void** outstanding_tags;
   size_t outstanding_tag_count;
   size_t outstanding_tag_capacity;
 #endif
@@ -287,99 +280,150 @@ struct grpc_completion_queue {
 };
 
 /* Forward declarations */
-static void cq_finish_shutdown_next(grpc_exec_ctx *exec_ctx,
-                                    grpc_completion_queue *cq);
-static void cq_finish_shutdown_pluck(grpc_exec_ctx *exec_ctx,
-                                     grpc_completion_queue *cq);
-static void cq_shutdown_next(grpc_exec_ctx *exec_ctx,
-                             grpc_completion_queue *cq);
-static void cq_shutdown_pluck(grpc_exec_ctx *exec_ctx,
-                              grpc_completion_queue *cq);
-
-static bool cq_begin_op_for_next(grpc_completion_queue *cq, void *tag);
-static bool cq_begin_op_for_pluck(grpc_completion_queue *cq, void *tag);
-
-static void cq_end_op_for_next(grpc_exec_ctx *exec_ctx,
-                               grpc_completion_queue *cq, void *tag,
-                               grpc_error *error,
-                               void (*done)(grpc_exec_ctx *exec_ctx,
-                                            void *done_arg,
-                                            grpc_cq_completion *storage),
-                               void *done_arg, grpc_cq_completion *storage);
-
-static void cq_end_op_for_pluck(grpc_exec_ctx *exec_ctx,
-                                grpc_completion_queue *cq, void *tag,
-                                grpc_error *error,
-                                void (*done)(grpc_exec_ctx *exec_ctx,
-                                             void *done_arg,
-                                             grpc_cq_completion *storage),
-                                void *done_arg, grpc_cq_completion *storage);
-
-static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
-                          void *reserved);
-
-static grpc_event cq_pluck(grpc_completion_queue *cq, void *tag,
-                           gpr_timespec deadline, void *reserved);
-
-static void cq_init_next(void *data);
-static void cq_init_pluck(void *data);
-static void cq_destroy_next(void *data);
-static void cq_destroy_pluck(void *data);
+static void cq_finish_shutdown_next(grpc_exec_ctx* exec_ctx,
+                                    grpc_completion_queue* cq);
+static void cq_finish_shutdown_pluck(grpc_exec_ctx* exec_ctx,
+                                     grpc_completion_queue* cq);
+static void cq_shutdown_next(grpc_exec_ctx* exec_ctx,
+                             grpc_completion_queue* cq);
+static void cq_shutdown_pluck(grpc_exec_ctx* exec_ctx,
+                              grpc_completion_queue* cq);
+
+static bool cq_begin_op_for_next(grpc_completion_queue* cq, void* tag);
+static bool cq_begin_op_for_pluck(grpc_completion_queue* cq, void* tag);
+
+static void cq_end_op_for_next(grpc_exec_ctx* exec_ctx,
+                               grpc_completion_queue* cq, void* tag,
+                               grpc_error* error,
+                               void (*done)(grpc_exec_ctx* exec_ctx,
+                                            void* done_arg,
+                                            grpc_cq_completion* storage),
+                               void* done_arg, grpc_cq_completion* storage);
+
+static void cq_end_op_for_pluck(grpc_exec_ctx* exec_ctx,
+                                grpc_completion_queue* cq, void* tag,
+                                grpc_error* error,
+                                void (*done)(grpc_exec_ctx* exec_ctx,
+                                             void* done_arg,
+                                             grpc_cq_completion* storage),
+                                void* done_arg, grpc_cq_completion* storage);
+
+static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
+                          void* reserved);
+
+static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
+                           gpr_timespec deadline, void* reserved);
+
+static void cq_init_next(void* data);
+static void cq_init_pluck(void* data);
+static void cq_destroy_next(void* data);
+static void cq_destroy_pluck(void* data);
 
 /* Completion queue vtables based on the completion-type */
 static const cq_vtable g_cq_vtable[] = {
     /* GRPC_CQ_NEXT */
     {GRPC_CQ_NEXT, sizeof(cq_next_data), cq_init_next, cq_shutdown_next,
-     cq_destroy_next, cq_begin_op_for_next, cq_end_op_for_next, cq_next, NULL},
+     cq_destroy_next, cq_begin_op_for_next, cq_end_op_for_next, cq_next,
+     nullptr},
     /* GRPC_CQ_PLUCK */
     {GRPC_CQ_PLUCK, sizeof(cq_pluck_data), cq_init_pluck, cq_shutdown_pluck,
-     cq_destroy_pluck, cq_begin_op_for_pluck, cq_end_op_for_pluck, NULL,
+     cq_destroy_pluck, cq_begin_op_for_pluck, cq_end_op_for_pluck, nullptr,
      cq_pluck},
 };
 
-#define DATA_FROM_CQ(cq) ((void *)(cq + 1))
+#define DATA_FROM_CQ(cq) ((void*)(cq + 1))
 #define POLLSET_FROM_CQ(cq) \
-  ((grpc_pollset *)(cq->vtable->data_size + (char *)DATA_FROM_CQ(cq)))
-
-grpc_tracer_flag grpc_cq_pluck_trace =
-    GRPC_TRACER_INITIALIZER(true, "queue_pluck");
-grpc_tracer_flag grpc_cq_event_timeout_trace =
-    GRPC_TRACER_INITIALIZER(true, "queue_timeout");
-
-#define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event)    \
-  if (GRPC_TRACER_ON(grpc_api_trace) &&                 \
-      (GRPC_TRACER_ON(grpc_cq_pluck_trace) ||           \
-       (event)->type != GRPC_QUEUE_TIMEOUT)) {          \
-    char *_ev = grpc_event_string(event);               \
-    gpr_log(GPR_INFO, "RETURN_EVENT[%p]: %s", cq, _ev); \
-    gpr_free(_ev);                                      \
+  ((grpc_pollset*)(cq->vtable->data_size + (char*)DATA_FROM_CQ(cq)))
+
+grpc_core::TraceFlag grpc_cq_pluck_trace(true, "queue_pluck");
+grpc_core::TraceFlag grpc_cq_event_timeout_trace(true, "queue_timeout");
+
+#define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event)                       \
+  if (grpc_api_trace.enabled() && (grpc_cq_pluck_trace.enabled() ||        \
+                                   (event)->type != GRPC_QUEUE_TIMEOUT)) { \
+    char* _ev = grpc_event_string(event);                                  \
+    gpr_log(GPR_INFO, "RETURN_EVENT[%p]: %s", cq, _ev);                    \
+    gpr_free(_ev);                                                         \
+  }
+
+static void on_pollset_shutdown_done(grpc_exec_ctx* exec_ctx, void* cq,
+                                     grpc_error* error);
+
+void grpc_cq_global_init() {
+  gpr_tls_init(&g_cached_event);
+  gpr_tls_init(&g_cached_cq);
+}
+
+void grpc_completion_queue_thread_local_cache_init(grpc_completion_queue* cq) {
+  if ((grpc_completion_queue*)gpr_tls_get(&g_cached_cq) == nullptr) {
+    gpr_tls_set(&g_cached_event, (intptr_t)0);
+    gpr_tls_set(&g_cached_cq, (intptr_t)cq);
+  }
+}
+
+int grpc_completion_queue_thread_local_cache_flush(grpc_completion_queue* cq,
+                                                   void** tag, int* ok) {
+  grpc_cq_completion* storage =
+      (grpc_cq_completion*)gpr_tls_get(&g_cached_event);
+  int ret = 0;
+  if (storage != nullptr &&
+      (grpc_completion_queue*)gpr_tls_get(&g_cached_cq) == cq) {
+    *tag = storage->tag;
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    *ok = (storage->next & (uintptr_t)(1)) == 1;
+    storage->done(&exec_ctx, storage->done_arg, storage);
+    ret = 1;
+    cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+    if (gpr_atm_full_fetch_add(&cqd->pending_events, -1) == 1) {
+      GRPC_CQ_INTERNAL_REF(cq, "shutting_down");
+      gpr_mu_lock(cq->mu);
+      cq_finish_shutdown_next(&exec_ctx, cq);
+      gpr_mu_unlock(cq->mu);
+      GRPC_CQ_INTERNAL_UNREF(&exec_ctx, cq, "shutting_down");
+    }
+    grpc_exec_ctx_finish(&exec_ctx);
   }
+  gpr_tls_set(&g_cached_event, (intptr_t)0);
+  gpr_tls_set(&g_cached_cq, (intptr_t)0);
 
-static void on_pollset_shutdown_done(grpc_exec_ctx *exec_ctx, void *cq,
-                                     grpc_error *error);
+  return ret;
+}
 
-static void cq_event_queue_init(grpc_cq_event_queue *q) {
+static void cq_event_queue_init(grpc_cq_event_queue* q) {
   gpr_mpscq_init(&q->queue);
   q->queue_lock = GPR_SPINLOCK_INITIALIZER;
   gpr_atm_no_barrier_store(&q->num_queue_items, 0);
 }
 
-static void cq_event_queue_destroy(grpc_cq_event_queue *q) {
+static void cq_event_queue_destroy(grpc_cq_event_queue* q) {
   gpr_mpscq_destroy(&q->queue);
 }
 
-static bool cq_event_queue_push(grpc_cq_event_queue *q, grpc_cq_completion *c) {
-  gpr_mpscq_push(&q->queue, (gpr_mpscq_node *)c);
+static bool cq_event_queue_push(grpc_cq_event_queue* q, grpc_cq_completion* c) {
+  gpr_mpscq_push(&q->queue, (gpr_mpscq_node*)c);
   return gpr_atm_no_barrier_fetch_add(&q->num_queue_items, 1) == 0;
 }
 
-static grpc_cq_completion *cq_event_queue_pop(grpc_cq_event_queue *q) {
-  grpc_cq_completion *c = NULL;
+static grpc_cq_completion* cq_event_queue_pop(grpc_cq_event_queue* q) {
+  grpc_cq_completion* c = nullptr;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+
   if (gpr_spinlock_trylock(&q->queue_lock)) {
-    c = (grpc_cq_completion *)gpr_mpscq_pop(&q->queue);
+    GRPC_STATS_INC_CQ_EV_QUEUE_TRYLOCK_SUCCESSES(&exec_ctx);
+
+    bool is_empty = false;
+    c = (grpc_cq_completion*)gpr_mpscq_pop_and_check_end(&q->queue, &is_empty);
     gpr_spinlock_unlock(&q->queue_lock);
+
+    if (c == nullptr && !is_empty) {
+      GRPC_STATS_INC_CQ_EV_QUEUE_TRANSIENT_POP_FAILURES(&exec_ctx);
+    }
+  } else {
+    GRPC_STATS_INC_CQ_EV_QUEUE_TRYLOCK_FAILURES(&exec_ctx);
   }
 
+  grpc_exec_ctx_finish(&exec_ctx);
+
   if (c) {
     gpr_atm_no_barrier_fetch_add(&q->num_queue_items, -1);
   }
@@ -389,14 +433,14 @@ static grpc_cq_completion *cq_event_queue_pop(grpc_cq_event_queue *q) {
 
 /* Note: The counter is not incremented/decremented atomically with push/pop.
  * The count is only eventually consistent */
-static long cq_event_queue_num_items(grpc_cq_event_queue *q) {
+static long cq_event_queue_num_items(grpc_cq_event_queue* q) {
   return (long)gpr_atm_no_barrier_load(&q->num_queue_items);
 }
 
-grpc_completion_queue *grpc_completion_queue_create_internal(
+grpc_completion_queue* grpc_completion_queue_create_internal(
     grpc_cq_completion_type completion_type,
     grpc_cq_polling_type polling_type) {
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
 
   GPR_TIMER_BEGIN("grpc_completion_queue_create_internal", 0);
 
@@ -405,17 +449,17 @@ grpc_completion_queue *grpc_completion_queue_create_internal(
       "polling_type=%d)",
       2, (completion_type, polling_type));
 
-  const cq_vtable *vtable = &g_cq_vtable[completion_type];
-  const cq_poller_vtable *poller_vtable =
+  const cq_vtable* vtable = &g_cq_vtable[completion_type];
+  const cq_poller_vtable* poller_vtable =
       &g_poller_vtable_by_poller_type[polling_type];
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   GRPC_STATS_INC_CQS_CREATED(&exec_ctx);
   grpc_exec_ctx_finish(&exec_ctx);
 
-  cq = (grpc_completion_queue *)gpr_zalloc(sizeof(grpc_completion_queue) +
-                                           vtable->data_size +
-                                           poller_vtable->size());
+  cq = (grpc_completion_queue*)gpr_zalloc(sizeof(grpc_completion_queue) +
+                                          vtable->data_size +
+                                          poller_vtable->size());
 
   cq->vtable = vtable;
   cq->poller_vtable = poller_vtable;
@@ -434,8 +478,8 @@ grpc_completion_queue *grpc_completion_queue_create_internal(
   return cq;
 }
 
-static void cq_init_next(void *ptr) {
-  cq_next_data *cqd = (cq_next_data *)ptr;
+static void cq_init_next(void* ptr) {
+  cq_next_data* cqd = (cq_next_data*)ptr;
   /* Initial count is dropped by grpc_completion_queue_shutdown */
   gpr_atm_no_barrier_store(&cqd->pending_events, 1);
   cqd->shutdown_called = false;
@@ -443,14 +487,14 @@ static void cq_init_next(void *ptr) {
   cq_event_queue_init(&cqd->queue);
 }
 
-static void cq_destroy_next(void *ptr) {
-  cq_next_data *cqd = (cq_next_data *)ptr;
+static void cq_destroy_next(void* ptr) {
+  cq_next_data* cqd = (cq_next_data*)ptr;
   GPR_ASSERT(cq_event_queue_num_items(&cqd->queue) == 0);
   cq_event_queue_destroy(&cqd->queue);
 }
 
-static void cq_init_pluck(void *ptr) {
-  cq_pluck_data *cqd = (cq_pluck_data *)ptr;
+static void cq_init_pluck(void* ptr) {
+  cq_pluck_data* cqd = (cq_pluck_data*)ptr;
   /* Initial count is dropped by grpc_completion_queue_shutdown */
   gpr_atm_no_barrier_store(&cqd->pending_events, 1);
   cqd->completed_tail = &cqd->completed_head;
@@ -461,16 +505,16 @@ static void cq_init_pluck(void *ptr) {
   gpr_atm_no_barrier_store(&cqd->things_queued_ever, 0);
 }
 
-static void cq_destroy_pluck(void *ptr) {
-  cq_pluck_data *cqd = (cq_pluck_data *)ptr;
+static void cq_destroy_pluck(void* ptr) {
+  cq_pluck_data* cqd = (cq_pluck_data*)ptr;
   GPR_ASSERT(cqd->completed_head.next == (uintptr_t)&cqd->completed_head);
 }
 
-grpc_cq_completion_type grpc_get_cq_completion_type(grpc_completion_queue *cq) {
+grpc_cq_completion_type grpc_get_cq_completion_type(grpc_completion_queue* cq) {
   return cq->vtable->cq_completion_type;
 }
 
-int grpc_get_cq_poll_num(grpc_completion_queue *cq) {
+int grpc_get_cq_poll_num(grpc_completion_queue* cq) {
   int cur_num_polls;
   gpr_mu_lock(cq->mu);
   cur_num_polls = cq->num_polls;
@@ -479,38 +523,38 @@ int grpc_get_cq_poll_num(grpc_completion_queue *cq) {
 }
 
 #ifndef NDEBUG
-void grpc_cq_internal_ref(grpc_completion_queue *cq, const char *reason,
-                          const char *file, int line) {
-  if (GRPC_TRACER_ON(grpc_trace_cq_refcount)) {
+void grpc_cq_internal_ref(grpc_completion_queue* cq, const char* reason,
+                          const char* file, int line) {
+  if (grpc_trace_cq_refcount.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&cq->owning_refs.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "CQ:%p   ref %" PRIdPTR " -> %" PRIdPTR " %s", cq, val, val + 1,
             reason);
   }
 #else
-void grpc_cq_internal_ref(grpc_completion_queue *cq) {
+void grpc_cq_internal_ref(grpc_completion_queue* cq) {
 #endif
   gpr_ref(&cq->owning_refs);
 }
 
-static void on_pollset_shutdown_done(grpc_exec_ctx *exec_ctx, void *arg,
-                                     grpc_error *error) {
-  grpc_completion_queue *cq = (grpc_completion_queue *)arg;
+static void on_pollset_shutdown_done(grpc_exec_ctx* exec_ctx, void* arg,
+                                     grpc_error* error) {
+  grpc_completion_queue* cq = (grpc_completion_queue*)arg;
   GRPC_CQ_INTERNAL_UNREF(exec_ctx, cq, "pollset_destroy");
 }
 
 #ifndef NDEBUG
-void grpc_cq_internal_unref(grpc_exec_ctx *exec_ctx, grpc_completion_queue *cq,
-                            const char *reason, const char *file, int line) {
-  if (GRPC_TRACER_ON(grpc_trace_cq_refcount)) {
+void grpc_cq_internal_unref(grpc_exec_ctx* exec_ctx, grpc_completion_queue* cq,
+                            const char* reason, const char* file, int line) {
+  if (grpc_trace_cq_refcount.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&cq->owning_refs.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "CQ:%p unref %" PRIdPTR " -> %" PRIdPTR " %s", cq, val, val - 1,
             reason);
   }
 #else
-void grpc_cq_internal_unref(grpc_exec_ctx *exec_ctx,
-                            grpc_completion_queue *cq) {
+void grpc_cq_internal_unref(grpc_exec_ctx* exec_ctx,
+                            grpc_completion_queue* cq) {
 #endif
   if (gpr_unref(&cq->owning_refs)) {
     cq->vtable->destroy(DATA_FROM_CQ(cq));
@@ -523,7 +567,7 @@ void grpc_cq_internal_unref(grpc_exec_ctx *exec_ctx,
 }
 
 #ifndef NDEBUG
-static void cq_check_tag(grpc_completion_queue *cq, void *tag, bool lock_cq) {
+static void cq_check_tag(grpc_completion_queue* cq, void* tag, bool lock_cq) {
   int found = 0;
   if (lock_cq) {
     gpr_mu_lock(cq->mu);
@@ -532,7 +576,7 @@ static void cq_check_tag(grpc_completion_queue *cq, void *tag, bool lock_cq) {
   for (int i = 0; i < (int)cq->outstanding_tag_count; i++) {
     if (cq->outstanding_tags[i] == tag) {
       cq->outstanding_tag_count--;
-      GPR_SWAP(void *, cq->outstanding_tags[i],
+      GPR_SWAP(void*, cq->outstanding_tags[i],
                cq->outstanding_tags[cq->outstanding_tag_count]);
       found = 1;
       break;
@@ -546,12 +590,12 @@ static void cq_check_tag(grpc_completion_queue *cq, void *tag, bool lock_cq) {
   GPR_ASSERT(found);
 }
 #else
-static void cq_check_tag(grpc_completion_queue *cq, void *tag, bool lock_cq) {}
+static void cq_check_tag(grpc_completion_queue* cq, void* tag, bool lock_cq) {}
 #endif
 
 /* Atomically increments a counter only if the counter is not zero. Returns
  * true if the increment was successful; false if the counter is zero */
-static bool atm_inc_if_nonzero(gpr_atm *counter) {
+static bool atm_inc_if_nonzero(gpr_atm* counter) {
   while (true) {
     gpr_atm count = gpr_atm_acq_load(counter);
     /* If zero, we are done. If not, we must to a CAS (instead of an atomic
@@ -567,22 +611,22 @@ static bool atm_inc_if_nonzero(gpr_atm *counter) {
   return true;
 }
 
-static bool cq_begin_op_for_next(grpc_completion_queue *cq, void *tag) {
-  cq_next_data *cqd = (cq_next_data *)DATA_FROM_CQ(cq);
+static bool cq_begin_op_for_next(grpc_completion_queue* cq, void* tag) {
+  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
   return atm_inc_if_nonzero(&cqd->pending_events);
 }
 
-static bool cq_begin_op_for_pluck(grpc_completion_queue *cq, void *tag) {
-  cq_pluck_data *cqd = (cq_pluck_data *)DATA_FROM_CQ(cq);
+static bool cq_begin_op_for_pluck(grpc_completion_queue* cq, void* tag) {
+  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
   return atm_inc_if_nonzero(&cqd->pending_events);
 }
 
-bool grpc_cq_begin_op(grpc_completion_queue *cq, void *tag) {
+bool grpc_cq_begin_op(grpc_completion_queue* cq, void* tag) {
 #ifndef NDEBUG
   gpr_mu_lock(cq->mu);
   if (cq->outstanding_tag_count == cq->outstanding_tag_capacity) {
     cq->outstanding_tag_capacity = GPR_MAX(4, 2 * cq->outstanding_tag_capacity);
-    cq->outstanding_tags = (void **)gpr_realloc(
+    cq->outstanding_tags = (void**)gpr_realloc(
         cq->outstanding_tags,
         sizeof(*cq->outstanding_tags) * cq->outstanding_tag_capacity);
   }
@@ -595,30 +639,27 @@ bool grpc_cq_begin_op(grpc_completion_queue *cq, void *tag) {
 /* Queue a GRPC_OP_COMPLETED operation to a completion queue (with a
  * completion
  * type of GRPC_CQ_NEXT) */
-static void cq_end_op_for_next(grpc_exec_ctx *exec_ctx,
-                               grpc_completion_queue *cq, void *tag,
-                               grpc_error *error,
-                               void (*done)(grpc_exec_ctx *exec_ctx,
-                                            void *done_arg,
-                                            grpc_cq_completion *storage),
-                               void *done_arg, grpc_cq_completion *storage) {
+static void cq_end_op_for_next(grpc_exec_ctx* exec_ctx,
+                               grpc_completion_queue* cq, void* tag,
+                               grpc_error* error,
+                               void (*done)(grpc_exec_ctx* exec_ctx,
+                                            void* done_arg,
+                                            grpc_cq_completion* storage),
+                               void* done_arg, grpc_cq_completion* storage) {
   GPR_TIMER_BEGIN("cq_end_op_for_next", 0);
 
-  if (GRPC_TRACER_ON(grpc_api_trace) ||
-      (GRPC_TRACER_ON(grpc_trace_operation_failures) &&
-       error != GRPC_ERROR_NONE)) {
-    const char *errmsg = grpc_error_string(error);
+  if (grpc_api_trace.enabled() ||
+      (grpc_trace_operation_failures.enabled() && error != GRPC_ERROR_NONE)) {
+    const char* errmsg = grpc_error_string(error);
     GRPC_API_TRACE(
         "cq_end_op_for_next(exec_ctx=%p, cq=%p, tag=%p, error=%s, "
         "done=%p, done_arg=%p, storage=%p)",
         7, (exec_ctx, cq, tag, errmsg, done, done_arg, storage));
-    if (GRPC_TRACER_ON(grpc_trace_operation_failures) &&
-        error != GRPC_ERROR_NONE) {
+    if (grpc_trace_operation_failures.enabled() && error != GRPC_ERROR_NONE) {
       gpr_log(GPR_ERROR, "Operation failed: tag=%p, error=%s", tag, errmsg);
     }
   }
-
-  cq_next_data *cqd = (cq_next_data *)DATA_FROM_CQ(cq);
+  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
   int is_success = (error == GRPC_ERROR_NONE);
 
   storage->tag = tag;
@@ -628,44 +669,50 @@ static void cq_end_op_for_next(grpc_exec_ctx *exec_ctx,
 
   cq_check_tag(cq, tag, true); /* Used in debug builds only */
 
-  /* Add the completion to the queue */
-  bool is_first = cq_event_queue_push(&cqd->queue, storage);
-  gpr_atm_no_barrier_fetch_add(&cqd->things_queued_ever, 1);
-
-  /* Since we do not hold the cq lock here, it is important to do an 'acquire'
-     load here (instead of a 'no_barrier' load) to match with the release store
-     (done via gpr_atm_full_fetch_add(pending_events, -1)) in cq_shutdown_next
-     */
-  bool will_definitely_shutdown = gpr_atm_acq_load(&cqd->pending_events) == 1;
-
-  if (!will_definitely_shutdown) {
-    /* Only kick if this is the first item queued */
-    if (is_first) {
-      gpr_mu_lock(cq->mu);
-      grpc_error *kick_error =
-          cq->poller_vtable->kick(exec_ctx, POLLSET_FROM_CQ(cq), NULL);
-      gpr_mu_unlock(cq->mu);
+  if ((grpc_completion_queue*)gpr_tls_get(&g_cached_cq) == cq &&
+      (grpc_cq_completion*)gpr_tls_get(&g_cached_event) == nullptr) {
+    gpr_tls_set(&g_cached_event, (intptr_t)storage);
+  } else {
+    /* Add the completion to the queue */
+    bool is_first = cq_event_queue_push(&cqd->queue, storage);
+    gpr_atm_no_barrier_fetch_add(&cqd->things_queued_ever, 1);
+
+    /* Since we do not hold the cq lock here, it is important to do an 'acquire'
+       load here (instead of a 'no_barrier' load) to match with the release
+       store
+       (done via gpr_atm_full_fetch_add(pending_events, -1)) in cq_shutdown_next
+       */
+    bool will_definitely_shutdown = gpr_atm_acq_load(&cqd->pending_events) == 1;
+
+    if (!will_definitely_shutdown) {
+      /* Only kick if this is the first item queued */
+      if (is_first) {
+        gpr_mu_lock(cq->mu);
+        grpc_error* kick_error =
+            cq->poller_vtable->kick(exec_ctx, POLLSET_FROM_CQ(cq), nullptr);
+        gpr_mu_unlock(cq->mu);
 
-      if (kick_error != GRPC_ERROR_NONE) {
-        const char *msg = grpc_error_string(kick_error);
-        gpr_log(GPR_ERROR, "Kick failed: %s", msg);
-        GRPC_ERROR_UNREF(kick_error);
+        if (kick_error != GRPC_ERROR_NONE) {
+          const char* msg = grpc_error_string(kick_error);
+          gpr_log(GPR_ERROR, "Kick failed: %s", msg);
+          GRPC_ERROR_UNREF(kick_error);
+        }
       }
-    }
-    if (gpr_atm_full_fetch_add(&cqd->pending_events, -1) == 1) {
+      if (gpr_atm_full_fetch_add(&cqd->pending_events, -1) == 1) {
+        GRPC_CQ_INTERNAL_REF(cq, "shutting_down");
+        gpr_mu_lock(cq->mu);
+        cq_finish_shutdown_next(exec_ctx, cq);
+        gpr_mu_unlock(cq->mu);
+        GRPC_CQ_INTERNAL_UNREF(exec_ctx, cq, "shutting_down");
+      }
+    } else {
       GRPC_CQ_INTERNAL_REF(cq, "shutting_down");
+      gpr_atm_rel_store(&cqd->pending_events, 0);
       gpr_mu_lock(cq->mu);
       cq_finish_shutdown_next(exec_ctx, cq);
       gpr_mu_unlock(cq->mu);
       GRPC_CQ_INTERNAL_UNREF(exec_ctx, cq, "shutting_down");
     }
-  } else {
-    GRPC_CQ_INTERNAL_REF(cq, "shutting_down");
-    gpr_atm_rel_store(&cqd->pending_events, 0);
-    gpr_mu_lock(cq->mu);
-    cq_finish_shutdown_next(exec_ctx, cq);
-    gpr_mu_unlock(cq->mu);
-    GRPC_CQ_INTERNAL_UNREF(exec_ctx, cq, "shutting_down");
   }
 
   GPR_TIMER_END("cq_end_op_for_next", 0);
@@ -676,28 +723,26 @@ static void cq_end_op_for_next(grpc_exec_ctx *exec_ctx,
 /* Queue a GRPC_OP_COMPLETED operation to a completion queue (with a
  * completion
  * type of GRPC_CQ_PLUCK) */
-static void cq_end_op_for_pluck(grpc_exec_ctx *exec_ctx,
-                                grpc_completion_queue *cq, void *tag,
-                                grpc_error *error,
-                                void (*done)(grpc_exec_ctx *exec_ctx,
-                                             void *done_arg,
-                                             grpc_cq_completion *storage),
-                                void *done_arg, grpc_cq_completion *storage) {
-  cq_pluck_data *cqd = (cq_pluck_data *)DATA_FROM_CQ(cq);
+static void cq_end_op_for_pluck(grpc_exec_ctx* exec_ctx,
+                                grpc_completion_queue* cq, void* tag,
+                                grpc_error* error,
+                                void (*done)(grpc_exec_ctx* exec_ctx,
+                                             void* done_arg,
+                                             grpc_cq_completion* storage),
+                                void* done_arg, grpc_cq_completion* storage) {
+  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
   int is_success = (error == GRPC_ERROR_NONE);
 
   GPR_TIMER_BEGIN("cq_end_op_for_pluck", 0);
 
-  if (GRPC_TRACER_ON(grpc_api_trace) ||
-      (GRPC_TRACER_ON(grpc_trace_operation_failures) &&
-       error != GRPC_ERROR_NONE)) {
-    const char *errmsg = grpc_error_string(error);
+  if (grpc_api_trace.enabled() ||
+      (grpc_trace_operation_failures.enabled() && error != GRPC_ERROR_NONE)) {
+    const char* errmsg = grpc_error_string(error);
     GRPC_API_TRACE(
         "cq_end_op_for_pluck(exec_ctx=%p, cq=%p, tag=%p, error=%s, "
         "done=%p, done_arg=%p, storage=%p)",
         7, (exec_ctx, cq, tag, errmsg, done, done_arg, storage));
-    if (GRPC_TRACER_ON(grpc_trace_operation_failures) &&
-        error != GRPC_ERROR_NONE) {
+    if (grpc_trace_operation_failures.enabled() && error != GRPC_ERROR_NONE) {
       gpr_log(GPR_ERROR, "Operation failed: tag=%p, error=%s", tag, errmsg);
     }
   }
@@ -720,7 +765,7 @@ static void cq_end_op_for_pluck(grpc_exec_ctx *exec_ctx,
     cq_finish_shutdown_pluck(exec_ctx, cq);
     gpr_mu_unlock(cq->mu);
   } else {
-    grpc_pollset_worker *pluck_worker = NULL;
+    grpc_pollset_worker* pluck_worker = nullptr;
     for (int i = 0; i < cqd->num_pluckers; i++) {
       if (cqd->pluckers[i].tag == tag) {
         pluck_worker = *cqd->pluckers[i].worker;
@@ -728,13 +773,13 @@ static void cq_end_op_for_pluck(grpc_exec_ctx *exec_ctx,
       }
     }
 
-    grpc_error *kick_error =
+    grpc_error* kick_error =
         cq->poller_vtable->kick(exec_ctx, POLLSET_FROM_CQ(cq), pluck_worker);
 
     gpr_mu_unlock(cq->mu);
 
     if (kick_error != GRPC_ERROR_NONE) {
-      const char *msg = grpc_error_string(kick_error);
+      const char* msg = grpc_error_string(kick_error);
       gpr_log(GPR_ERROR, "Kick failed: %s", msg);
 
       GRPC_ERROR_UNREF(kick_error);
@@ -746,28 +791,28 @@ static void cq_end_op_for_pluck(grpc_exec_ctx *exec_ctx,
   GRPC_ERROR_UNREF(error);
 }
 
-void grpc_cq_end_op(grpc_exec_ctx *exec_ctx, grpc_completion_queue *cq,
-                    void *tag, grpc_error *error,
-                    void (*done)(grpc_exec_ctx *exec_ctx, void *done_arg,
-                                 grpc_cq_completion *storage),
-                    void *done_arg, grpc_cq_completion *storage) {
+void grpc_cq_end_op(grpc_exec_ctx* exec_ctx, grpc_completion_queue* cq,
+                    void* tag, grpc_error* error,
+                    void (*done)(grpc_exec_ctx* exec_ctx, void* done_arg,
+                                 grpc_cq_completion* storage),
+                    void* done_arg, grpc_cq_completion* storage) {
   cq->vtable->end_op(exec_ctx, cq, tag, error, done, done_arg, storage);
 }
 
 typedef struct {
   gpr_atm last_seen_things_queued_ever;
-  grpc_completion_queue *cq;
-  gpr_timespec deadline;
-  grpc_cq_completion *stolen_completion;
-  void *tag; /* for pluck */
+  grpc_completion_queue* cq;
+  grpc_millis deadline;
+  grpc_cq_completion* stolen_completion;
+  void* tag; /* for pluck */
   bool first_loop;
 } cq_is_finished_arg;
 
-static bool cq_is_next_finished(grpc_exec_ctx *exec_ctx, void *arg) {
-  cq_is_finished_arg *a = (cq_is_finished_arg *)arg;
-  grpc_completion_queue *cq = a->cq;
-  cq_next_data *cqd = (cq_next_data *)DATA_FROM_CQ(cq);
-  GPR_ASSERT(a->stolen_completion == NULL);
+static bool cq_is_next_finished(grpc_exec_ctx* exec_ctx, void* arg) {
+  cq_is_finished_arg* a = (cq_is_finished_arg*)arg;
+  grpc_completion_queue* cq = a->cq;
+  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+  GPR_ASSERT(a->stolen_completion == nullptr);
 
   gpr_atm current_last_seen_things_queued_ever =
       gpr_atm_no_barrier_load(&cqd->things_queued_ever);
@@ -782,42 +827,40 @@ static bool cq_is_next_finished(grpc_exec_ctx *exec_ctx, void *arg) {
      * is ok and doesn't affect correctness. Might effect the tail latencies a
      * bit) */
     a->stolen_completion = cq_event_queue_pop(&cqd->queue);
-    if (a->stolen_completion != NULL) {
+    if (a->stolen_completion != nullptr) {
       return true;
     }
   }
-  return !a->first_loop &&
-         gpr_time_cmp(a->deadline, gpr_now(a->deadline.clock_type)) < 0;
+  return !a->first_loop && a->deadline < grpc_exec_ctx_now(exec_ctx);
 }
 
 #ifndef NDEBUG
-static void dump_pending_tags(grpc_completion_queue *cq) {
-  if (!GRPC_TRACER_ON(grpc_trace_pending_tags)) return;
+static void dump_pending_tags(grpc_completion_queue* cq) {
+  if (!grpc_trace_pending_tags.enabled()) return;
 
   gpr_strvec v;
   gpr_strvec_init(&v);
   gpr_strvec_add(&v, gpr_strdup("PENDING TAGS:"));
   gpr_mu_lock(cq->mu);
   for (size_t i = 0; i < cq->outstanding_tag_count; i++) {
-    char *s;
+    char* s;
     gpr_asprintf(&s, " %p", cq->outstanding_tags[i]);
     gpr_strvec_add(&v, s);
   }
   gpr_mu_unlock(cq->mu);
-  char *out = gpr_strvec_flatten(&v, NULL);
+  char* out = gpr_strvec_flatten(&v, nullptr);
   gpr_strvec_destroy(&v);
   gpr_log(GPR_DEBUG, "%s", out);
   gpr_free(out);
 }
 #else
-static void dump_pending_tags(grpc_completion_queue *cq) {}
+static void dump_pending_tags(grpc_completion_queue* cq) {}
 #endif
 
-static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
-                          void *reserved) {
+static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
+                          void* reserved) {
   grpc_event ret;
-  gpr_timespec now;
-  cq_next_data *cqd = (cq_next_data *)DATA_FROM_CQ(cq);
+  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
 
   GPR_TIMER_BEGIN("grpc_completion_queue_next", 0);
 
@@ -827,33 +870,31 @@ static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
       "deadline=gpr_timespec { tv_sec: %" PRId64
       ", tv_nsec: %d, clock_type: %d }, "
       "reserved=%p)",
-      5, (cq, deadline.tv_sec, deadline.tv_nsec, (int)deadline.clock_type,
-          reserved));
+      5,
+      (cq, deadline.tv_sec, deadline.tv_nsec, (int)deadline.clock_type,
+       reserved));
   GPR_ASSERT(!reserved);
 
   dump_pending_tags(cq);
 
-  deadline = gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC);
-
   GRPC_CQ_INTERNAL_REF(cq, "next");
 
+  grpc_millis deadline_millis = grpc_timespec_to_millis_round_up(deadline);
   cq_is_finished_arg is_finished_arg = {
-      .last_seen_things_queued_ever =
-          gpr_atm_no_barrier_load(&cqd->things_queued_ever),
-      .cq = cq,
-      .deadline = deadline,
-      .stolen_completion = NULL,
-      .tag = NULL,
-      .first_loop = true};
+      gpr_atm_no_barrier_load(&cqd->things_queued_ever),
+      cq,
+      deadline_millis,
+      nullptr,
+      nullptr,
+      true};
   grpc_exec_ctx exec_ctx =
       GRPC_EXEC_CTX_INITIALIZER(0, cq_is_next_finished, &is_finished_arg);
-
   for (;;) {
-    gpr_timespec iteration_deadline = deadline;
+    grpc_millis iteration_deadline = deadline_millis;
 
-    if (is_finished_arg.stolen_completion != NULL) {
-      grpc_cq_completion *c = is_finished_arg.stolen_completion;
-      is_finished_arg.stolen_completion = NULL;
+    if (is_finished_arg.stolen_completion != nullptr) {
+      grpc_cq_completion* c = is_finished_arg.stolen_completion;
+      is_finished_arg.stolen_completion = nullptr;
       ret.type = GRPC_OP_COMPLETE;
       ret.success = c->next & 1u;
       ret.tag = c->tag;
@@ -861,9 +902,9 @@ static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
       break;
     }
 
-    grpc_cq_completion *c = cq_event_queue_pop(&cqd->queue);
+    grpc_cq_completion* c = cq_event_queue_pop(&cqd->queue);
 
-    if (c != NULL) {
+    if (c != nullptr) {
       ret.type = GRPC_OP_COMPLETE;
       ret.success = c->next & 1u;
       ret.tag = c->tag;
@@ -876,7 +917,7 @@ static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
          attempt at popping. Not doing this can potentially deadlock this
          thread forever (if the deadline is infinity) */
       if (cq_event_queue_num_items(&cqd->queue) > 0) {
-        iteration_deadline = gpr_time_0(GPR_CLOCK_MONOTONIC);
+        iteration_deadline = 0;
       }
     }
 
@@ -897,8 +938,8 @@ static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
       break;
     }
 
-    now = gpr_now(GPR_CLOCK_MONOTONIC);
-    if (!is_finished_arg.first_loop && gpr_time_cmp(now, deadline) >= 0) {
+    if (!is_finished_arg.first_loop &&
+        grpc_exec_ctx_now(&exec_ctx) >= deadline_millis) {
       memset(&ret, 0, sizeof(ret));
       ret.type = GRPC_QUEUE_TIMEOUT;
       dump_pending_tags(cq);
@@ -908,12 +949,12 @@ static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
     /* The main polling work happens in grpc_pollset_work */
     gpr_mu_lock(cq->mu);
     cq->num_polls++;
-    grpc_error *err = cq->poller_vtable->work(&exec_ctx, POLLSET_FROM_CQ(cq),
-                                              NULL, now, iteration_deadline);
+    grpc_error* err = cq->poller_vtable->work(&exec_ctx, POLLSET_FROM_CQ(cq),
+                                              nullptr, iteration_deadline);
     gpr_mu_unlock(cq->mu);
 
     if (err != GRPC_ERROR_NONE) {
-      const char *msg = grpc_error_string(err);
+      const char* msg = grpc_error_string(err);
       gpr_log(GPR_ERROR, "Completion queue next failed: %s", msg);
 
       GRPC_ERROR_UNREF(err);
@@ -928,14 +969,14 @@ static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
   if (cq_event_queue_num_items(&cqd->queue) > 0 &&
       gpr_atm_acq_load(&cqd->pending_events) > 0) {
     gpr_mu_lock(cq->mu);
-    cq->poller_vtable->kick(&exec_ctx, POLLSET_FROM_CQ(cq), NULL);
+    cq->poller_vtable->kick(&exec_ctx, POLLSET_FROM_CQ(cq), nullptr);
     gpr_mu_unlock(cq->mu);
   }
 
   GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, &ret);
   GRPC_CQ_INTERNAL_UNREF(&exec_ctx, cq, "next");
   grpc_exec_ctx_finish(&exec_ctx);
-  GPR_ASSERT(is_finished_arg.stolen_completion == NULL);
+  GPR_ASSERT(is_finished_arg.stolen_completion == nullptr);
 
   GPR_TIMER_END("grpc_completion_queue_next", 0);
 
@@ -948,9 +989,9 @@ static grpc_event cq_next(grpc_completion_queue *cq, gpr_timespec deadline,
    - Must be called only once in completion queue's lifetime
    - grpc_completion_queue_shutdown() MUST have been called before calling
    this function */
-static void cq_finish_shutdown_next(grpc_exec_ctx *exec_ctx,
-                                    grpc_completion_queue *cq) {
-  cq_next_data *cqd = (cq_next_data *)DATA_FROM_CQ(cq);
+static void cq_finish_shutdown_next(grpc_exec_ctx* exec_ctx,
+                                    grpc_completion_queue* cq) {
+  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
 
   GPR_ASSERT(cqd->shutdown_called);
   GPR_ASSERT(gpr_atm_no_barrier_load(&cqd->pending_events) == 0);
@@ -959,9 +1000,9 @@ static void cq_finish_shutdown_next(grpc_exec_ctx *exec_ctx,
                               &cq->pollset_shutdown_done);
 }
 
-static void cq_shutdown_next(grpc_exec_ctx *exec_ctx,
-                             grpc_completion_queue *cq) {
-  cq_next_data *cqd = (cq_next_data *)DATA_FROM_CQ(cq);
+static void cq_shutdown_next(grpc_exec_ctx* exec_ctx,
+                             grpc_completion_queue* cq) {
+  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
 
   /* Need an extra ref for cq here because:
    * We call cq_finish_shutdown_next() below, that would call pollset shutdown.
@@ -987,14 +1028,14 @@ static void cq_shutdown_next(grpc_exec_ctx *exec_ctx,
   GRPC_CQ_INTERNAL_UNREF(exec_ctx, cq, "shutting_down");
 }
 
-grpc_event grpc_completion_queue_next(grpc_completion_queue *cq,
-                                      gpr_timespec deadline, void *reserved) {
+grpc_event grpc_completion_queue_next(grpc_completion_queue* cq,
+                                      gpr_timespec deadline, void* reserved) {
   return cq->vtable->next(cq, deadline, reserved);
 }
 
-static int add_plucker(grpc_completion_queue *cq, void *tag,
-                       grpc_pollset_worker **worker) {
-  cq_pluck_data *cqd = (cq_pluck_data *)DATA_FROM_CQ(cq);
+static int add_plucker(grpc_completion_queue* cq, void* tag,
+                       grpc_pollset_worker** worker) {
+  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
   if (cqd->num_pluckers == GRPC_MAX_COMPLETION_QUEUE_PLUCKERS) {
     return 0;
   }
@@ -1004,9 +1045,9 @@ static int add_plucker(grpc_completion_queue *cq, void *tag,
   return 1;
 }
 
-static void del_plucker(grpc_completion_queue *cq, void *tag,
-                        grpc_pollset_worker **worker) {
-  cq_pluck_data *cqd = (cq_pluck_data *)DATA_FROM_CQ(cq);
+static void del_plucker(grpc_completion_queue* cq, void* tag,
+                        grpc_pollset_worker** worker) {
+  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
   for (int i = 0; i < cqd->num_pluckers; i++) {
     if (cqd->pluckers[i].tag == tag && cqd->pluckers[i].worker == worker) {
       cqd->num_pluckers--;
@@ -1017,21 +1058,21 @@ static void del_plucker(grpc_completion_queue *cq, void *tag,
   GPR_UNREACHABLE_CODE(return );
 }
 
-static bool cq_is_pluck_finished(grpc_exec_ctx *exec_ctx, void *arg) {
-  cq_is_finished_arg *a = (cq_is_finished_arg *)arg;
-  grpc_completion_queue *cq = a->cq;
-  cq_pluck_data *cqd = (cq_pluck_data *)DATA_FROM_CQ(cq);
+static bool cq_is_pluck_finished(grpc_exec_ctx* exec_ctx, void* arg) {
+  cq_is_finished_arg* a = (cq_is_finished_arg*)arg;
+  grpc_completion_queue* cq = a->cq;
+  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
 
-  GPR_ASSERT(a->stolen_completion == NULL);
+  GPR_ASSERT(a->stolen_completion == nullptr);
   gpr_atm current_last_seen_things_queued_ever =
       gpr_atm_no_barrier_load(&cqd->things_queued_ever);
   if (current_last_seen_things_queued_ever != a->last_seen_things_queued_ever) {
     gpr_mu_lock(cq->mu);
     a->last_seen_things_queued_ever =
         gpr_atm_no_barrier_load(&cqd->things_queued_ever);
-    grpc_cq_completion *c;
-    grpc_cq_completion *prev = &cqd->completed_head;
-    while ((c = (grpc_cq_completion *)(prev->next & ~(uintptr_t)1)) !=
+    grpc_cq_completion* c;
+    grpc_cq_completion* prev = &cqd->completed_head;
+    while ((c = (grpc_cq_completion*)(prev->next & ~(uintptr_t)1)) !=
            &cqd->completed_head) {
       if (c->tag == a->tag) {
         prev->next = (prev->next & (uintptr_t)1) | (c->next & ~(uintptr_t)1);
@@ -1046,54 +1087,51 @@ static bool cq_is_pluck_finished(grpc_exec_ctx *exec_ctx, void *arg) {
     }
     gpr_mu_unlock(cq->mu);
   }
-  return !a->first_loop &&
-         gpr_time_cmp(a->deadline, gpr_now(a->deadline.clock_type)) < 0;
+  return !a->first_loop && a->deadline < grpc_exec_ctx_now(exec_ctx);
 }
 
-static grpc_event cq_pluck(grpc_completion_queue *cq, void *tag,
-                           gpr_timespec deadline, void *reserved) {
+static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
+                           gpr_timespec deadline, void* reserved) {
   grpc_event ret;
-  grpc_cq_completion *c;
-  grpc_cq_completion *prev;
-  grpc_pollset_worker *worker = NULL;
-  gpr_timespec now;
-  cq_pluck_data *cqd = (cq_pluck_data *)DATA_FROM_CQ(cq);
+  grpc_cq_completion* c;
+  grpc_cq_completion* prev;
+  grpc_pollset_worker* worker = nullptr;
+  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
 
   GPR_TIMER_BEGIN("grpc_completion_queue_pluck", 0);
 
-  if (GRPC_TRACER_ON(grpc_cq_pluck_trace)) {
+  if (grpc_cq_pluck_trace.enabled()) {
     GRPC_API_TRACE(
         "grpc_completion_queue_pluck("
         "cq=%p, tag=%p, "
         "deadline=gpr_timespec { tv_sec: %" PRId64
         ", tv_nsec: %d, clock_type: %d }, "
         "reserved=%p)",
-        6, (cq, tag, deadline.tv_sec, deadline.tv_nsec,
-            (int)deadline.clock_type, reserved));
+        6,
+        (cq, tag, deadline.tv_sec, deadline.tv_nsec, (int)deadline.clock_type,
+         reserved));
   }
   GPR_ASSERT(!reserved);
 
   dump_pending_tags(cq);
 
-  deadline = gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC);
-
   GRPC_CQ_INTERNAL_REF(cq, "pluck");
   gpr_mu_lock(cq->mu);
+  grpc_millis deadline_millis = grpc_timespec_to_millis_round_up(deadline);
   cq_is_finished_arg is_finished_arg = {
-      .last_seen_things_queued_ever =
-          gpr_atm_no_barrier_load(&cqd->things_queued_ever),
-      .cq = cq,
-      .deadline = deadline,
-      .stolen_completion = NULL,
-      .tag = tag,
-      .first_loop = true};
+      gpr_atm_no_barrier_load(&cqd->things_queued_ever),
+      cq,
+      deadline_millis,
+      nullptr,
+      tag,
+      true};
   grpc_exec_ctx exec_ctx =
       GRPC_EXEC_CTX_INITIALIZER(0, cq_is_pluck_finished, &is_finished_arg);
   for (;;) {
-    if (is_finished_arg.stolen_completion != NULL) {
+    if (is_finished_arg.stolen_completion != nullptr) {
       gpr_mu_unlock(cq->mu);
       c = is_finished_arg.stolen_completion;
-      is_finished_arg.stolen_completion = NULL;
+      is_finished_arg.stolen_completion = nullptr;
       ret.type = GRPC_OP_COMPLETE;
       ret.success = c->next & 1u;
       ret.tag = c->tag;
@@ -1101,7 +1139,7 @@ static grpc_event cq_pluck(grpc_completion_queue *cq, void *tag,
       break;
     }
     prev = &cqd->completed_head;
-    while ((c = (grpc_cq_completion *)(prev->next & ~(uintptr_t)1)) !=
+    while ((c = (grpc_cq_completion*)(prev->next & ~(uintptr_t)1)) !=
            &cqd->completed_head) {
       if (c->tag == tag) {
         prev->next = (prev->next & (uintptr_t)1) | (c->next & ~(uintptr_t)1);
@@ -1135,8 +1173,8 @@ static grpc_event cq_pluck(grpc_completion_queue *cq, void *tag,
       dump_pending_tags(cq);
       break;
     }
-    now = gpr_now(GPR_CLOCK_MONOTONIC);
-    if (!is_finished_arg.first_loop && gpr_time_cmp(now, deadline) >= 0) {
+    if (!is_finished_arg.first_loop &&
+        grpc_exec_ctx_now(&exec_ctx) >= deadline_millis) {
       del_plucker(cq, tag, &worker);
       gpr_mu_unlock(cq->mu);
       memset(&ret, 0, sizeof(ret));
@@ -1144,14 +1182,13 @@ static grpc_event cq_pluck(grpc_completion_queue *cq, void *tag,
       dump_pending_tags(cq);
       break;
     }
-
     cq->num_polls++;
-    grpc_error *err = cq->poller_vtable->work(&exec_ctx, POLLSET_FROM_CQ(cq),
-                                              &worker, now, deadline);
+    grpc_error* err = cq->poller_vtable->work(&exec_ctx, POLLSET_FROM_CQ(cq),
+                                              &worker, deadline_millis);
     if (err != GRPC_ERROR_NONE) {
       del_plucker(cq, tag, &worker);
       gpr_mu_unlock(cq->mu);
-      const char *msg = grpc_error_string(err);
+      const char* msg = grpc_error_string(err);
       gpr_log(GPR_ERROR, "Completion queue pluck failed: %s", msg);
 
       GRPC_ERROR_UNREF(err);
@@ -1167,21 +1204,21 @@ done:
   GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, &ret);
   GRPC_CQ_INTERNAL_UNREF(&exec_ctx, cq, "pluck");
   grpc_exec_ctx_finish(&exec_ctx);
-  GPR_ASSERT(is_finished_arg.stolen_completion == NULL);
+  GPR_ASSERT(is_finished_arg.stolen_completion == nullptr);
 
   GPR_TIMER_END("grpc_completion_queue_pluck", 0);
 
   return ret;
 }
 
-grpc_event grpc_completion_queue_pluck(grpc_completion_queue *cq, void *tag,
-                                       gpr_timespec deadline, void *reserved) {
+grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
+                                       gpr_timespec deadline, void* reserved) {
   return cq->vtable->pluck(cq, tag, deadline, reserved);
 }
 
-static void cq_finish_shutdown_pluck(grpc_exec_ctx *exec_ctx,
-                                     grpc_completion_queue *cq) {
-  cq_pluck_data *cqd = (cq_pluck_data *)DATA_FROM_CQ(cq);
+static void cq_finish_shutdown_pluck(grpc_exec_ctx* exec_ctx,
+                                     grpc_completion_queue* cq) {
+  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
 
   GPR_ASSERT(cqd->shutdown_called);
   GPR_ASSERT(!gpr_atm_no_barrier_load(&cqd->shutdown));
@@ -1193,9 +1230,9 @@ static void cq_finish_shutdown_pluck(grpc_exec_ctx *exec_ctx,
 
 /* NOTE: This function is almost exactly identical to cq_shutdown_next() but
  * merging them is a bit tricky and probably not worth it */
-static void cq_shutdown_pluck(grpc_exec_ctx *exec_ctx,
-                              grpc_completion_queue *cq) {
-  cq_pluck_data *cqd = (cq_pluck_data *)DATA_FROM_CQ(cq);
+static void cq_shutdown_pluck(grpc_exec_ctx* exec_ctx,
+                              grpc_completion_queue* cq) {
+  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
 
   /* Need an extra ref for cq here because:
    * We call cq_finish_shutdown_pluck() below, that would call pollset shutdown.
@@ -1220,7 +1257,7 @@ static void cq_shutdown_pluck(grpc_exec_ctx *exec_ctx,
 
 /* Shutdown simply drops a ref that we reserved at creation time; if we drop
    to zero here, then enter shutdown mode and wake up any waiters */
-void grpc_completion_queue_shutdown(grpc_completion_queue *cq) {
+void grpc_completion_queue_shutdown(grpc_completion_queue* cq) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   GPR_TIMER_BEGIN("grpc_completion_queue_shutdown", 0);
   GRPC_API_TRACE("grpc_completion_queue_shutdown(cq=%p)", 1, (cq));
@@ -1229,7 +1266,7 @@ void grpc_completion_queue_shutdown(grpc_completion_queue *cq) {
   GPR_TIMER_END("grpc_completion_queue_shutdown", 0);
 }
 
-void grpc_completion_queue_destroy(grpc_completion_queue *cq) {
+void grpc_completion_queue_destroy(grpc_completion_queue* cq) {
   GRPC_API_TRACE("grpc_completion_queue_destroy(cq=%p)", 1, (cq));
   GPR_TIMER_BEGIN("grpc_completion_queue_destroy", 0);
   grpc_completion_queue_shutdown(cq);
@@ -1240,10 +1277,10 @@ void grpc_completion_queue_destroy(grpc_completion_queue *cq) {
   GPR_TIMER_END("grpc_completion_queue_destroy", 0);
 }
 
-grpc_pollset *grpc_cq_pollset(grpc_completion_queue *cq) {
-  return cq->poller_vtable->can_get_pollset ? POLLSET_FROM_CQ(cq) : NULL;
+grpc_pollset* grpc_cq_pollset(grpc_completion_queue* cq) {
+  return cq->poller_vtable->can_get_pollset ? POLLSET_FROM_CQ(cq) : nullptr;
 }
 
-bool grpc_cq_can_listen(grpc_completion_queue *cq) {
+bool grpc_cq_can_listen(grpc_completion_queue* cq) {
   return cq->poller_vtable->can_listen;
 }