From 3150744c712449585e6c0a3347f2b9366671a8eb Mon Sep 17 00:00:00 2001
From: Yash Tibrewal <yashkt@google.com>
Date: Thu, 9 Nov 2017 18:27:37 -0800
Subject: [PATCH] Removing more exec_ctx instances

---
 test/core/surface/completion_queue_test.cc    |  16 +-
 test/cpp/common/channel_filter_test.cc        |   4 +-
 test/cpp/end2end/client_lb_end2end_test.cc    |  12 +-
 test/cpp/end2end/filter_end2end_test.cc       |   7 +-
 test/cpp/end2end/grpclb_end2end_test.cc       |  10 +-
 test/cpp/grpclb/grpclb_test.cc                |  16 +-
 test/cpp/microbenchmarks/bm_call_create.cc    | 136 ++++-----
 test/cpp/microbenchmarks/bm_chttp2_hpack.cc   | 126 ++++-----
 .../microbenchmarks/bm_chttp2_transport.cc    | 265 ++++++++----------
 test/cpp/microbenchmarks/bm_closure.cc        | 155 +++++-----
 test/cpp/microbenchmarks/bm_cq.cc             |  20 +-
 .../microbenchmarks/bm_cq_multiple_threads.cc |  22 +-
 test/cpp/microbenchmarks/bm_error.cc          |  18 +-
 .../microbenchmarks/bm_fullstack_trickle.cc   |   6 +-
 test/cpp/microbenchmarks/bm_metadata.cc       |  93 +++---
 test/cpp/microbenchmarks/bm_pollset.cc        |  44 ++-
 test/cpp/microbenchmarks/fullstack_fixtures.h |  23 +-
 test/cpp/naming/resolver_component_test.cc    |  48 ++--
 test/cpp/performance/writes_per_rpc_test.cc   |  18 +-
 19 files changed, 479 insertions(+), 560 deletions(-)

diff --git a/test/core/surface/completion_queue_test.cc b/test/core/surface/completion_queue_test.cc
index 63d8ea62684..f014738f4cb 100644
--- a/test/core/surface/completion_queue_test.cc
+++ b/test/core/surface/completion_queue_test.cc
@@ -129,8 +129,6 @@ static void test_cq_end_op(void) {
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
   grpc_completion_queue_attributes attr;
-  grpc_exec_ctx init_exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_exec_ctx exec_ctx;
   void* tag = create_test_tag();
 
   LOG_TEST("test_cq_end_op");
@@ -138,7 +136,7 @@ static void test_cq_end_op(void) {
   attr.version = 1;
   attr.cq_completion_type = GRPC_CQ_NEXT;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
-    exec_ctx = init_exec_ctx;  // Reset exec_ctx
+    ExecCtx _local_exec_ctx;
     attr.cq_polling_type = polling_types[i];
     cc = grpc_completion_queue_create(
         grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
@@ -164,8 +162,6 @@ static void test_cq_tls_cache_full(void) {
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
   grpc_completion_queue_attributes attr;
-  grpc_exec_ctx init_exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_exec_ctx exec_ctx;
   void* tag = create_test_tag();
   void* res_tag;
   int ok;
@@ -175,7 +171,7 @@ static void test_cq_tls_cache_full(void) {
   attr.version = 1;
   attr.cq_completion_type = GRPC_CQ_NEXT;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
-    exec_ctx = init_exec_ctx;  // Reset exec_ctx
+    ExecCtx _local_exec_ctx;  // Reset exec_ctx
     attr.cq_polling_type = polling_types[i];
     cc = grpc_completion_queue_create(
         grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
@@ -206,8 +202,6 @@ static void test_cq_tls_cache_empty(void) {
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
   grpc_completion_queue_attributes attr;
-  grpc_exec_ctx init_exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_exec_ctx exec_ctx;
   void* res_tag;
   int ok;
 
@@ -216,7 +210,7 @@ static void test_cq_tls_cache_empty(void) {
   attr.version = 1;
   attr.cq_completion_type = GRPC_CQ_NEXT;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(polling_types); i++) {
-    exec_ctx = init_exec_ctx;  // Reset exec_ctx
+    ExecCtx _local_exec_ctx;  // Reset exec_ctx
     attr.cq_polling_type = polling_types[i];
     cc = grpc_completion_queue_create(
         grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
@@ -284,8 +278,6 @@ static void test_pluck(void) {
   grpc_cq_polling_type polling_types[] = {
       GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_NON_LISTENING, GRPC_CQ_NON_POLLING};
   grpc_completion_queue_attributes attr;
-  grpc_exec_ctx init_exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_exec_ctx exec_ctx;
   unsigned i, j;
 
   LOG_TEST("test_pluck");
@@ -300,7 +292,7 @@ static void test_pluck(void) {
   attr.version = 1;
   attr.cq_completion_type = GRPC_CQ_PLUCK;
   for (size_t pidx = 0; pidx < GPR_ARRAY_SIZE(polling_types); pidx++) {
-    exec_ctx = init_exec_ctx;  // reset exec_ctx
+    ExecCtx _local_exec_ctx;  // reset exec_ctx
     attr.cq_polling_type = polling_types[pidx];
     cc = grpc_completion_queue_create(
         grpc_completion_queue_factory_lookup(&attr), &attr, NULL);
diff --git a/test/cpp/common/channel_filter_test.cc b/test/cpp/common/channel_filter_test.cc
index 638518107bb..7bdd53f9e7a 100644
--- a/test/cpp/common/channel_filter_test.cc
+++ b/test/cpp/common/channel_filter_test.cc
@@ -28,7 +28,7 @@ class MyChannelData : public ChannelData {
  public:
   MyChannelData() {}
 
-  grpc_error* Init(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+  grpc_error* Init(grpc_channel_element* elem,
                    grpc_channel_element_args* args) override {
     (void)args->channel_args;  // Make sure field is available.
     return GRPC_ERROR_NONE;
@@ -39,7 +39,7 @@ class MyCallData : public CallData {
  public:
   MyCallData() {}
 
-  grpc_error* Init(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+  grpc_error* Init(grpc_call_element* elem,
                    const grpc_call_element_args* args) override {
     (void)args->path;  // Make sure field is available.
     return GRPC_ERROR_NONE;
diff --git a/test/cpp/end2end/client_lb_end2end_test.cc b/test/cpp/end2end/client_lb_end2end_test.cc
index b2bbe56889d..df2ed0ecd00 100644
--- a/test/cpp/end2end/client_lb_end2end_test.cc
+++ b/test/cpp/end2end/client_lb_end2end_test.cc
@@ -117,7 +117,7 @@ class ClientLbEnd2endTest : public ::testing::Test {
     for (size_t i = 0; i < ports.size(); ++i) {
       char* lb_uri_str;
       gpr_asprintf(&lb_uri_str, "ipv4:127.0.0.1:%d", ports[i]);
-      grpc_uri* lb_uri = grpc_uri_parse(&exec_ctx, lb_uri_str, true);
+      grpc_uri* lb_uri = grpc_uri_parse(lb_uri_str, true);
       GPR_ASSERT(lb_uri != NULL);
       grpc_lb_addresses_set_address_from_uri(addresses, i, lb_uri,
                                              false /* is balancer */,
@@ -129,11 +129,11 @@ class ClientLbEnd2endTest : public ::testing::Test {
         grpc_lb_addresses_create_channel_arg(addresses);
     grpc_channel_args* fake_result =
         grpc_channel_args_copy_and_add(NULL, &fake_addresses, 1);
-    grpc_fake_resolver_response_generator_set_response(
-        &exec_ctx, response_generator_, fake_result);
-    grpc_channel_args_destroy(&exec_ctx, fake_result);
-    grpc_lb_addresses_destroy(&exec_ctx, addresses);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_fake_resolver_response_generator_set_response(response_generator_,
+                                                       fake_result);
+    grpc_channel_args_destroy(fake_result);
+    grpc_lb_addresses_destroy(addresses);
+    grpc_exec_ctx_finish();
   }
 
   void ResetStub(const grpc::string& lb_policy_name = "") {
diff --git a/test/cpp/end2end/filter_end2end_test.cc b/test/cpp/end2end/filter_end2end_test.cc
index f260ea0016d..c4430379dbf 100644
--- a/test/cpp/end2end/filter_end2end_test.cc
+++ b/test/cpp/end2end/filter_end2end_test.cc
@@ -100,7 +100,7 @@ int GetCallCounterValue() {
 
 class ChannelDataImpl : public ChannelData {
  public:
-  grpc_error* Init(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+  grpc_error* Init(grpc_channel_element* elem,
                    grpc_channel_element_args* args) {
     IncrementConnectionCounter();
     return GRPC_ERROR_NONE;
@@ -109,13 +109,12 @@ class ChannelDataImpl : public ChannelData {
 
 class CallDataImpl : public CallData {
  public:
-  void StartTransportStreamOpBatch(grpc_exec_ctx* exec_ctx,
-                                   grpc_call_element* elem,
+  void StartTransportStreamOpBatch(grpc_call_element* elem,
                                    TransportStreamOpBatch* op) override {
     // Incrementing the counter could be done from Init(), but we want
     // to test that the individual methods are actually called correctly.
     if (op->recv_initial_metadata() != nullptr) IncrementCallCounter();
-    grpc_call_next_op(exec_ctx, elem, op->op());
+    grpc_call_next_op(elem, op->op());
   }
 };
 
diff --git a/test/cpp/end2end/grpclb_end2end_test.cc b/test/cpp/end2end/grpclb_end2end_test.cc
index a6682b3e2f0..62d7094d4ca 100644
--- a/test/cpp/end2end/grpclb_end2end_test.cc
+++ b/test/cpp/end2end/grpclb_end2end_test.cc
@@ -457,7 +457,7 @@ class GrpclbEnd2endTest : public ::testing::Test {
     for (size_t i = 0; i < address_data.size(); ++i) {
       char* lb_uri_str;
       gpr_asprintf(&lb_uri_str, "ipv4:127.0.0.1:%d", address_data[i].port);
-      grpc_uri* lb_uri = grpc_uri_parse(&exec_ctx, lb_uri_str, true);
+      grpc_uri* lb_uri = grpc_uri_parse(lb_uri_str, true);
       GPR_ASSERT(lb_uri != nullptr);
       grpc_lb_addresses_set_address_from_uri(
           addresses, i, lb_uri, address_data[i].is_balancer,
@@ -467,10 +467,10 @@ class GrpclbEnd2endTest : public ::testing::Test {
     }
     grpc_arg fake_addresses = grpc_lb_addresses_create_channel_arg(addresses);
     grpc_channel_args fake_result = {1, &fake_addresses};
-    grpc_fake_resolver_response_generator_set_response(
-        &exec_ctx, response_generator_, &fake_result);
-    grpc_lb_addresses_destroy(&exec_ctx, addresses);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_fake_resolver_response_generator_set_response(response_generator_,
+                                                       &fake_result);
+    grpc_lb_addresses_destroy(addresses);
+    grpc_exec_ctx_finish();
   }
 
   const std::vector<int> GetBackendPorts(const size_t start_index = 0) const {
diff --git a/test/cpp/grpclb/grpclb_test.cc b/test/cpp/grpclb/grpclb_test.cc
index 0955e2683d4..c2c6c0b3370 100644
--- a/test/cpp/grpclb/grpclb_test.cc
+++ b/test/cpp/grpclb/grpclb_test.cc
@@ -570,7 +570,7 @@ static void setup_client(const server_fixture* lb_server,
   grpc_lb_addresses* addresses = grpc_lb_addresses_create(1, NULL);
   char* lb_uri_str;
   gpr_asprintf(&lb_uri_str, "ipv4:%s", lb_server->servers_hostport);
-  grpc_uri* lb_uri = grpc_uri_parse(&exec_ctx, lb_uri_str, true);
+  grpc_uri* lb_uri = grpc_uri_parse(lb_uri_str, true);
   GPR_ASSERT(lb_uri != NULL);
   grpc_lb_addresses_set_address_from_uri(addresses, 0, lb_uri, true,
                                          lb_server->balancer_name, NULL);
@@ -582,7 +582,7 @@ static void setup_client(const server_fixture* lb_server,
       grpc_lb_addresses_create_channel_arg(addresses);
   grpc_channel_args* fake_result =
       grpc_channel_args_copy_and_add(NULL, &fake_addresses, 1);
-  grpc_lb_addresses_destroy(&exec_ctx, addresses);
+  grpc_lb_addresses_destroy(addresses);
 
   const grpc_arg new_args[] = {
       grpc_fake_transport_expected_targets_arg(expected_target_names),
@@ -597,13 +597,13 @@ static void setup_client(const server_fixture* lb_server,
       grpc_fake_transport_security_credentials_create();
   cf->client =
       grpc_secure_channel_create(fake_creds, cf->server_uri, args, NULL);
-  grpc_fake_resolver_response_generator_set_response(
-      &exec_ctx, response_generator, fake_result);
-  grpc_channel_args_destroy(&exec_ctx, fake_result);
-  grpc_channel_credentials_unref(&exec_ctx, fake_creds);
-  grpc_channel_args_destroy(&exec_ctx, args);
+  grpc_fake_resolver_response_generator_set_response(response_generator,
+                                                     fake_result);
+  grpc_channel_args_destroy(fake_result);
+  grpc_channel_credentials_unref(fake_creds);
+  grpc_channel_args_destroy(args);
   grpc_fake_resolver_response_generator_unref(response_generator);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
 }
 
 static void teardown_client(client_fixture* cf) {
diff --git a/test/cpp/microbenchmarks/bm_call_create.cc b/test/cpp/microbenchmarks/bm_call_create.cc
index c031aff1bb0..eac1c753c7a 100644
--- a/test/cpp/microbenchmarks/bm_call_create.cc
+++ b/test/cpp/microbenchmarks/bm_call_create.cc
@@ -311,12 +311,9 @@ static void BM_LameChannelCallCreateCoreSeparateBatch(benchmark::State& state) {
 }
 BENCHMARK(BM_LameChannelCallCreateCoreSeparateBatch);
 
-static void FilterDestroy(grpc_exec_ctx* exec_ctx, void* arg,
-                          grpc_error* error) {
-  gpr_free(arg);
-}
+static void FilterDestroy(void* arg, grpc_error* error) { gpr_free(arg); }
 
-static void DoNothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
+static void DoNothing(void* arg, grpc_error* error) {}
 
 class FakeClientChannelFactory : public grpc_client_channel_factory {
  public:
@@ -324,15 +321,12 @@ class FakeClientChannelFactory : public grpc_client_channel_factory {
 
  private:
   static void NoRef(grpc_client_channel_factory* factory) {}
-  static void NoUnref(grpc_exec_ctx* exec_ctx,
-                      grpc_client_channel_factory* factory) {}
-  static grpc_subchannel* CreateSubchannel(grpc_exec_ctx* exec_ctx,
-                                           grpc_client_channel_factory* factory,
+  static void NoUnref(grpc_client_channel_factory* factory) {}
+  static grpc_subchannel* CreateSubchannel(grpc_client_channel_factory* factory,
                                            const grpc_subchannel_args* args) {
     return nullptr;
   }
-  static grpc_channel* CreateClientChannel(grpc_exec_ctx* exec_ctx,
-                                           grpc_client_channel_factory* factory,
+  static grpc_channel* CreateClientChannel(grpc_client_channel_factory* factory,
                                            const char* target,
                                            grpc_client_channel_type type,
                                            const grpc_channel_args* args) {
@@ -366,36 +360,32 @@ struct Fixture {
 
 namespace dummy_filter {
 
-static void StartTransportStreamOp(grpc_exec_ctx* exec_ctx,
-                                   grpc_call_element* elem,
+static void StartTransportStreamOp(grpc_call_element* elem,
                                    grpc_transport_stream_op_batch* op) {}
 
-static void StartTransportOp(grpc_exec_ctx* exec_ctx,
-                             grpc_channel_element* elem,
+static void StartTransportOp(grpc_channel_element* elem,
                              grpc_transport_op* op) {}
 
-static grpc_error* InitCallElem(grpc_exec_ctx* exec_ctx,
-                                grpc_call_element* elem,
+static grpc_error* InitCallElem(grpc_call_element* elem,
                                 const grpc_call_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void SetPollsetOrPollsetSet(grpc_exec_ctx* exec_ctx,
-                                   grpc_call_element* elem,
+static void SetPollsetOrPollsetSet(grpc_call_element* elem,
                                    grpc_polling_entity* pollent) {}
 
-static void DestroyCallElem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+static void DestroyCallElem(grpc_call_element* elem,
                             const grpc_call_final_info* final_info,
                             grpc_closure* then_sched_closure) {}
 
-grpc_error* InitChannelElem(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+grpc_error* InitChannelElem(grpc_channel_element* elem,
                             grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-void DestroyChannelElem(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem) {}
+void DestroyChannelElem(grpc_channel_element* elem) {}
 
-void GetChannelInfo(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+void GetChannelInfo(grpc_channel_element* elem,
                     const grpc_channel_info* channel_info) {}
 
 static const grpc_channel_filter dummy_filter = {StartTransportStreamOp,
@@ -422,41 +412,38 @@ size_t sizeof_stream; /* = sizeof(transport stream) */
 const char* name;
 
 /* implementation of grpc_transport_init_stream */
-int InitStream(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-               grpc_stream* stream, grpc_stream_refcount* refcount,
-               const void* server_data, gpr_arena* arena) {
+int InitStream(grpc_transport* self, grpc_stream* stream,
+               grpc_stream_refcount* refcount, const void* server_data,
+               gpr_arena* arena) {
   return 0;
 }
 
 /* implementation of grpc_transport_set_pollset */
-void SetPollset(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                grpc_stream* stream, grpc_pollset* pollset) {}
+void SetPollset(grpc_transport* self, grpc_stream* stream,
+                grpc_pollset* pollset) {}
 
 /* implementation of grpc_transport_set_pollset */
-void SetPollsetSet(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                   grpc_stream* stream, grpc_pollset_set* pollset_set) {}
+void SetPollsetSet(grpc_transport* self, grpc_stream* stream,
+                   grpc_pollset_set* pollset_set) {}
 
 /* implementation of grpc_transport_perform_stream_op */
-void PerformStreamOp(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                     grpc_stream* stream, grpc_transport_stream_op_batch* op) {
-  GRPC_CLOSURE_SCHED(exec_ctx, op->on_complete, GRPC_ERROR_NONE);
+void PerformStreamOp(grpc_transport* self, grpc_stream* stream,
+                     grpc_transport_stream_op_batch* op) {
+  GRPC_CLOSURE_SCHED(op->on_complete, GRPC_ERROR_NONE);
 }
 
 /* implementation of grpc_transport_perform_op */
-void PerformOp(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-               grpc_transport_op* op) {}
+void PerformOp(grpc_transport* self, grpc_transport_op* op) {}
 
 /* implementation of grpc_transport_destroy_stream */
-void DestroyStream(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                   grpc_stream* stream, grpc_closure* then_sched_closure) {}
+void DestroyStream(grpc_transport* self, grpc_stream* stream,
+                   grpc_closure* then_sched_closure) {}
 
 /* implementation of grpc_transport_destroy */
-void Destroy(grpc_exec_ctx* exec_ctx, grpc_transport* self) {}
+void Destroy(grpc_transport* self) {}
 
 /* implementation of grpc_transport_get_endpoint */
-grpc_endpoint* GetEndpoint(grpc_exec_ctx* exec_ctx, grpc_transport* self) {
-  return nullptr;
-}
+grpc_endpoint* GetEndpoint(grpc_transport* self) { return nullptr; }
 
 static const grpc_transport_vtable dummy_transport_vtable = {
     0,          "dummy_http2", InitStream,
@@ -472,8 +459,8 @@ class NoOp {
  public:
   class Op {
    public:
-    Op(grpc_exec_ctx* exec_ctx, NoOp* p, grpc_call_stack* s) {}
-    void Finish(grpc_exec_ctx* exec_ctx) {}
+    Op(NoOp* p, grpc_call_stack* s) {}
+    void Finish() {}
   };
 };
 
@@ -489,13 +476,11 @@ class SendEmptyMetadata {
 
   class Op {
    public:
-    Op(grpc_exec_ctx* exec_ctx, SendEmptyMetadata* p, grpc_call_stack* s) {
+    Op(SendEmptyMetadata* p, grpc_call_stack* s) {
       grpc_metadata_batch_init(&batch_);
       p->op_payload_.send_initial_metadata.send_initial_metadata = &batch_;
     }
-    void Finish(grpc_exec_ctx* exec_ctx) {
-      grpc_metadata_batch_destroy(exec_ctx, &batch_);
-    }
+    void Finish() { grpc_metadata_batch_destroy(&batch_); }
 
    private:
     grpc_metadata_batch batch_;
@@ -543,13 +528,13 @@ static void BM_IsolatedFilter(benchmark::State& state) {
       static_cast<grpc_channel_stack*>(gpr_zalloc(channel_size));
   GPR_ASSERT(GRPC_LOG_IF_ERROR(
       "channel_stack_init",
-      grpc_channel_stack_init(&exec_ctx, 1, FilterDestroy, channel_stack,
-                              &filters[0], filters.size(), &channel_args,
+      grpc_channel_stack_init(1, FilterDestroy, channel_stack, &filters[0],
+                              filters.size(), &channel_args,
                               fixture.flags & REQUIRES_TRANSPORT
                                   ? &dummy_transport::dummy_transport
                                   : nullptr,
                               "CHANNEL", channel_stack)));
-  grpc_exec_ctx_flush(&exec_ctx);
+  grpc_exec_ctx_flush();
   grpc_call_stack* call_stack =
       static_cast<grpc_call_stack*>(gpr_zalloc(channel_stack->call_stack_size));
   grpc_millis deadline = GRPC_MILLIS_INF_FUTURE;
@@ -568,12 +553,12 @@ static void BM_IsolatedFilter(benchmark::State& state) {
   call_args.arena = gpr_arena_create(kArenaSize);
   while (state.KeepRunning()) {
     GPR_TIMER_SCOPE("BenchmarkCycle", 0);
-    GRPC_ERROR_UNREF(grpc_call_stack_init(&exec_ctx, channel_stack, 1,
-                                          DoNothing, NULL, &call_args));
-    typename TestOp::Op op(&exec_ctx, &test_op_data, call_stack);
-    grpc_call_stack_destroy(&exec_ctx, call_stack, &final_info, NULL);
-    op.Finish(&exec_ctx);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_ERROR_UNREF(
+        grpc_call_stack_init(channel_stack, 1, DoNothing, NULL, &call_args));
+    typename TestOp::Op op(&test_op_data, call_stack);
+    grpc_call_stack_destroy(call_stack, &final_info, NULL);
+    op.Finish();
+    grpc_exec_ctx_flush();
     // recreate arena every 64k iterations to avoid oom
     if (0 == (state.iterations() & 0xffff)) {
       gpr_arena_destroy(call_args.arena);
@@ -581,8 +566,8 @@ static void BM_IsolatedFilter(benchmark::State& state) {
     }
   }
   gpr_arena_destroy(call_args.arena);
-  grpc_channel_stack_destroy(&exec_ctx, channel_stack);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_channel_stack_destroy(channel_stack);
+  grpc_exec_ctx_finish();
   gpr_free(channel_stack);
   gpr_free(call_stack);
 
@@ -632,59 +617,55 @@ typedef struct {
   grpc_call_combiner* call_combiner;
 } call_data;
 
-static void StartTransportStreamOp(grpc_exec_ctx* exec_ctx,
-                                   grpc_call_element* elem,
+static void StartTransportStreamOp(grpc_call_element* elem,
                                    grpc_transport_stream_op_batch* op) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (op->recv_initial_metadata) {
     GRPC_CALL_COMBINER_START(
-        exec_ctx, calld->call_combiner,
+        calld->call_combiner,
         op->payload->recv_initial_metadata.recv_initial_metadata_ready,
         GRPC_ERROR_NONE, "recv_initial_metadata");
   }
   if (op->recv_message) {
-    GRPC_CALL_COMBINER_START(exec_ctx, calld->call_combiner,
+    GRPC_CALL_COMBINER_START(calld->call_combiner,
                              op->payload->recv_message.recv_message_ready,
                              GRPC_ERROR_NONE, "recv_message");
   }
-  GRPC_CLOSURE_SCHED(exec_ctx, op->on_complete, GRPC_ERROR_NONE);
+  GRPC_CLOSURE_SCHED(op->on_complete, GRPC_ERROR_NONE);
 }
 
-static void StartTransportOp(grpc_exec_ctx* exec_ctx,
-                             grpc_channel_element* elem,
+static void StartTransportOp(grpc_channel_element* elem,
                              grpc_transport_op* op) {
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
     GRPC_ERROR_UNREF(op->disconnect_with_error);
   }
-  GRPC_CLOSURE_SCHED(exec_ctx, op->on_consumed, GRPC_ERROR_NONE);
+  GRPC_CLOSURE_SCHED(op->on_consumed, GRPC_ERROR_NONE);
 }
 
-static grpc_error* InitCallElem(grpc_exec_ctx* exec_ctx,
-                                grpc_call_element* elem,
+static grpc_error* InitCallElem(grpc_call_element* elem,
                                 const grpc_call_element_args* args) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->call_combiner = args->call_combiner;
   return GRPC_ERROR_NONE;
 }
 
-static void SetPollsetOrPollsetSet(grpc_exec_ctx* exec_ctx,
-                                   grpc_call_element* elem,
+static void SetPollsetOrPollsetSet(grpc_call_element* elem,
                                    grpc_polling_entity* pollent) {}
 
-static void DestroyCallElem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+static void DestroyCallElem(grpc_call_element* elem,
                             const grpc_call_final_info* final_info,
                             grpc_closure* then_sched_closure) {
-  GRPC_CLOSURE_SCHED(exec_ctx, then_sched_closure, GRPC_ERROR_NONE);
+  GRPC_CLOSURE_SCHED(then_sched_closure, GRPC_ERROR_NONE);
 }
 
-grpc_error* InitChannelElem(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+grpc_error* InitChannelElem(grpc_channel_element* elem,
                             grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-void DestroyChannelElem(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem) {}
+void DestroyChannelElem(grpc_channel_element* elem) {}
 
-void GetChannelInfo(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+void GetChannelInfo(grpc_channel_element* elem,
                     const grpc_channel_info* channel_info) {}
 
 static const grpc_channel_filter isolated_call_filter = {
@@ -711,9 +692,8 @@ class IsolatedCallFixture : public TrackCounters {
         builder, &isolated_call_filter::isolated_call_filter, NULL, NULL));
     {
       ExecCtx _local_exec_ctx;
-      channel_ = grpc_channel_create_with_builder(&exec_ctx, builder,
-                                                  GRPC_CLIENT_CHANNEL);
-      grpc_exec_ctx_finish(&exec_ctx);
+      channel_ = grpc_channel_create_with_builder(builder, GRPC_CLIENT_CHANNEL);
+      grpc_exec_ctx_finish();
     }
     cq_ = grpc_completion_queue_create_for_next(NULL);
   }
diff --git a/test/cpp/microbenchmarks/bm_chttp2_hpack.cc b/test/cpp/microbenchmarks/bm_chttp2_hpack.cc
index a1bfc6997f8..f9d02ee5041 100644
--- a/test/cpp/microbenchmarks/bm_chttp2_hpack.cc
+++ b/test/cpp/microbenchmarks/bm_chttp2_hpack.cc
@@ -54,10 +54,10 @@ static void BM_HpackEncoderInitDestroy(benchmark::State& state) {
   grpc_chttp2_hpack_compressor c;
   while (state.KeepRunning()) {
     grpc_chttp2_hpack_compressor_init(&c);
-    grpc_chttp2_hpack_compressor_destroy(&exec_ctx, &c);
-    grpc_exec_ctx_flush(&exec_ctx);
+    grpc_chttp2_hpack_compressor_destroy(&c);
+    grpc_exec_ctx_flush();
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_HpackEncoderInitDestroy);
@@ -65,7 +65,7 @@ BENCHMARK(BM_HpackEncoderInitDestroy);
 static void BM_HpackEncoderEncodeDeadline(benchmark::State& state) {
   TrackCounters track_counters;
   ExecCtx _local_exec_ctx;
-  grpc_millis saved_now = grpc_exec_ctx_now(&exec_ctx);
+  grpc_millis saved_now = grpc_exec_ctx_now();
 
   grpc_metadata_batch b;
   grpc_metadata_batch_init(&b);
@@ -85,14 +85,14 @@ static void BM_HpackEncoderEncodeDeadline(benchmark::State& state) {
         (size_t)1024,
         &stats,
     };
-    grpc_chttp2_encode_header(&exec_ctx, &c, NULL, 0, &b, &hopt, &outbuf);
-    grpc_slice_buffer_reset_and_unref_internal(&exec_ctx, &outbuf);
-    grpc_exec_ctx_flush(&exec_ctx);
+    grpc_chttp2_encode_header(&c, NULL, 0, &b, &hopt, &outbuf);
+    grpc_slice_buffer_reset_and_unref_internal(&outbuf);
+    grpc_exec_ctx_flush();
   }
-  grpc_metadata_batch_destroy(&exec_ctx, &b);
-  grpc_chttp2_hpack_compressor_destroy(&exec_ctx, &c);
-  grpc_slice_buffer_destroy_internal(&exec_ctx, &outbuf);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_metadata_batch_destroy(&b);
+  grpc_chttp2_hpack_compressor_destroy(&c);
+  grpc_slice_buffer_destroy_internal(&outbuf);
+  grpc_exec_ctx_finish();
 
   std::ostringstream label;
   label << "framing_bytes/iter:"
@@ -114,12 +114,11 @@ static void BM_HpackEncoderEncodeHeader(benchmark::State& state) {
 
   grpc_metadata_batch b;
   grpc_metadata_batch_init(&b);
-  std::vector<grpc_mdelem> elems = Fixture::GetElems(&exec_ctx);
+  std::vector<grpc_mdelem> elems = Fixture::GetElems();
   std::vector<grpc_linked_mdelem> storage(elems.size());
   for (size_t i = 0; i < elems.size(); i++) {
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
-        "addmd",
-        grpc_metadata_batch_add_tail(&exec_ctx, &b, &storage[i], elems[i])));
+        "addmd", grpc_metadata_batch_add_tail(&b, &storage[i], elems[i])));
   }
 
   grpc_chttp2_hpack_compressor c;
@@ -136,7 +135,7 @@ static void BM_HpackEncoderEncodeHeader(benchmark::State& state) {
         (size_t)state.range(1),
         &stats,
     };
-    grpc_chttp2_encode_header(&exec_ctx, &c, NULL, 0, &b, &hopt, &outbuf);
+    grpc_chttp2_encode_header(&c, NULL, 0, &b, &hopt, &outbuf);
     if (!logged_representative_output && state.iterations() > 3) {
       logged_representative_output = true;
       for (size_t i = 0; i < outbuf.count; i++) {
@@ -145,13 +144,13 @@ static void BM_HpackEncoderEncodeHeader(benchmark::State& state) {
         gpr_free(s);
       }
     }
-    grpc_slice_buffer_reset_and_unref_internal(&exec_ctx, &outbuf);
-    grpc_exec_ctx_flush(&exec_ctx);
+    grpc_slice_buffer_reset_and_unref_internal(&outbuf);
+    grpc_exec_ctx_flush();
   }
-  grpc_metadata_batch_destroy(&exec_ctx, &b);
-  grpc_chttp2_hpack_compressor_destroy(&exec_ctx, &c);
-  grpc_slice_buffer_destroy_internal(&exec_ctx, &outbuf);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_metadata_batch_destroy(&b);
+  grpc_chttp2_hpack_compressor_destroy(&c);
+  grpc_slice_buffer_destroy_internal(&outbuf);
+  grpc_exec_ctx_finish();
 
   std::ostringstream label;
   label << "framing_bytes/iter:"
@@ -169,15 +168,13 @@ namespace hpack_encoder_fixtures {
 class EmptyBatch {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
-    return {};
-  }
+  static std::vector<grpc_mdelem> GetElems() { return {}; }
 };
 
 class SingleStaticElem {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     return {GRPC_MDELEM_GRPC_ACCEPT_ENCODING_IDENTITY_COMMA_DEFLATE};
   }
 };
@@ -185,9 +182,9 @@ class SingleStaticElem {
 class SingleInternedElem {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     return {grpc_mdelem_from_slices(
-        exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
+        grpc_slice_intern(grpc_slice_from_static_string("abc")),
         grpc_slice_intern(grpc_slice_from_static_string("def")))};
   }
 };
@@ -196,10 +193,10 @@ template <int kLength, bool kTrueBinary>
 class SingleInternedBinaryElem {
  public:
   static constexpr bool kEnableTrueBinary = kTrueBinary;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     grpc_slice bytes = MakeBytes();
     std::vector<grpc_mdelem> out = {grpc_mdelem_from_slices(
-        exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc-bin")),
+        grpc_slice_intern(grpc_slice_from_static_string("abc-bin")),
         grpc_slice_intern(bytes))};
     grpc_slice_unref(bytes);
     return out;
@@ -218,9 +215,9 @@ class SingleInternedBinaryElem {
 class SingleInternedKeyElem {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     return {grpc_mdelem_from_slices(
-        exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
+        grpc_slice_intern(grpc_slice_from_static_string("abc")),
         grpc_slice_from_static_string("def"))};
   }
 };
@@ -228,9 +225,8 @@ class SingleInternedKeyElem {
 class SingleNonInternedElem {
  public:
   static constexpr bool kEnableTrueBinary = false;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
-    return {grpc_mdelem_from_slices(exec_ctx,
-                                    grpc_slice_from_static_string("abc"),
+  static std::vector<grpc_mdelem> GetElems() {
+    return {grpc_mdelem_from_slices(grpc_slice_from_static_string("abc"),
                                     grpc_slice_from_static_string("def"))};
   }
 };
@@ -239,9 +235,9 @@ template <int kLength, bool kTrueBinary>
 class SingleNonInternedBinaryElem {
  public:
   static constexpr bool kEnableTrueBinary = kTrueBinary;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
-    return {grpc_mdelem_from_slices(
-        exec_ctx, grpc_slice_from_static_string("abc-bin"), MakeBytes())};
+  static std::vector<grpc_mdelem> GetElems() {
+    return {grpc_mdelem_from_slices(grpc_slice_from_static_string("abc-bin"),
+                                    MakeBytes())};
   }
 
  private:
@@ -257,21 +253,21 @@ class SingleNonInternedBinaryElem {
 class RepresentativeClientInitialMetadata {
  public:
   static constexpr bool kEnableTrueBinary = true;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     return {
         GRPC_MDELEM_SCHEME_HTTP,
         GRPC_MDELEM_METHOD_POST,
         grpc_mdelem_from_slices(
-            exec_ctx, GRPC_MDSTR_PATH,
+            GRPC_MDSTR_PATH,
             grpc_slice_intern(grpc_slice_from_static_string("/foo/bar"))),
-        grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_AUTHORITY,
+        grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY,
                                 grpc_slice_intern(grpc_slice_from_static_string(
                                     "foo.test.google.fr:1234"))),
         GRPC_MDELEM_GRPC_ACCEPT_ENCODING_IDENTITY_COMMA_DEFLATE_COMMA_GZIP,
         GRPC_MDELEM_TE_TRAILERS,
         GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
         grpc_mdelem_from_slices(
-            exec_ctx, GRPC_MDSTR_USER_AGENT,
+            GRPC_MDSTR_USER_AGENT,
             grpc_slice_intern(grpc_slice_from_static_string(
                 "grpc-c/3.0.0-dev (linux; chttp2; green)")))};
   }
@@ -283,18 +279,18 @@ class RepresentativeClientInitialMetadata {
 class MoreRepresentativeClientInitialMetadata {
  public:
   static constexpr bool kEnableTrueBinary = true;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     return {
         GRPC_MDELEM_SCHEME_HTTP,
         GRPC_MDELEM_METHOD_POST,
-        grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_PATH,
+        grpc_mdelem_from_slices(GRPC_MDSTR_PATH,
                                 grpc_slice_intern(grpc_slice_from_static_string(
                                     "/grpc.test.FooService/BarMethod"))),
-        grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_AUTHORITY,
+        grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY,
                                 grpc_slice_intern(grpc_slice_from_static_string(
                                     "foo.test.google.fr:1234"))),
         grpc_mdelem_from_slices(
-            exec_ctx, GRPC_MDSTR_GRPC_TRACE_BIN,
+            GRPC_MDSTR_GRPC_TRACE_BIN,
             grpc_slice_from_static_string("\x00\x01\x02\x03\x04\x05\x06\x07\x08"
                                           "\x09\x0a\x0b\x0c\x0d\x0e\x0f"
                                           "\x10\x11\x12\x13\x14\x15\x16\x17\x18"
@@ -303,7 +299,7 @@ class MoreRepresentativeClientInitialMetadata {
                                           "\x29\x2a\x2b\x2c\x2d\x2e\x2f"
                                           "\x30")),
         grpc_mdelem_from_slices(
-            exec_ctx, GRPC_MDSTR_GRPC_TAGS_BIN,
+            GRPC_MDSTR_GRPC_TAGS_BIN,
             grpc_slice_from_static_string("\x00\x01\x02\x03\x04\x05\x06\x07\x08"
                                           "\x09\x0a\x0b\x0c\x0d\x0e\x0f"
                                           "\x10\x11\x12\x13")),
@@ -311,7 +307,7 @@ class MoreRepresentativeClientInitialMetadata {
         GRPC_MDELEM_TE_TRAILERS,
         GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
         grpc_mdelem_from_slices(
-            exec_ctx, GRPC_MDSTR_USER_AGENT,
+            GRPC_MDSTR_USER_AGENT,
             grpc_slice_intern(grpc_slice_from_static_string(
                 "grpc-c/3.0.0-dev (linux; chttp2; green)")))};
   }
@@ -320,7 +316,7 @@ class MoreRepresentativeClientInitialMetadata {
 class RepresentativeServerInitialMetadata {
  public:
   static constexpr bool kEnableTrueBinary = true;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     return {GRPC_MDELEM_STATUS_200,
             GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
             GRPC_MDELEM_GRPC_ACCEPT_ENCODING_IDENTITY_COMMA_DEFLATE_COMMA_GZIP};
@@ -330,7 +326,7 @@ class RepresentativeServerInitialMetadata {
 class RepresentativeServerTrailingMetadata {
  public:
   static constexpr bool kEnableTrueBinary = true;
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     return {GRPC_MDELEM_GRPC_STATUS_0};
   }
 };
@@ -434,18 +430,17 @@ static void BM_HpackParserInitDestroy(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   grpc_chttp2_hpack_parser p;
   while (state.KeepRunning()) {
-    grpc_chttp2_hpack_parser_init(&exec_ctx, &p);
-    grpc_chttp2_hpack_parser_destroy(&exec_ctx, &p);
-    grpc_exec_ctx_flush(&exec_ctx);
+    grpc_chttp2_hpack_parser_init(&p);
+    grpc_chttp2_hpack_parser_destroy(&p);
+    grpc_exec_ctx_flush();
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_HpackParserInitDestroy);
 
-static void UnrefHeader(grpc_exec_ctx* exec_ctx, void* user_data,
-                        grpc_mdelem md) {
-  GRPC_MDELEM_UNREF(exec_ctx, md);
+static void UnrefHeader(void* user_data, grpc_mdelem md) {
+  GRPC_MDELEM_UNREF(md);
 }
 
 template <class Fixture, void (*OnHeader)(grpc_exec_ctx*, void*, grpc_mdelem)>
@@ -455,24 +450,22 @@ static void BM_HpackParserParseHeader(benchmark::State& state) {
   std::vector<grpc_slice> init_slices = Fixture::GetInitSlices();
   std::vector<grpc_slice> benchmark_slices = Fixture::GetBenchmarkSlices();
   grpc_chttp2_hpack_parser p;
-  grpc_chttp2_hpack_parser_init(&exec_ctx, &p);
+  grpc_chttp2_hpack_parser_init(&p);
   p.on_header = OnHeader;
   p.on_header_user_data = nullptr;
   for (auto slice : init_slices) {
-    GPR_ASSERT(GRPC_ERROR_NONE ==
-               grpc_chttp2_hpack_parser_parse(&exec_ctx, &p, slice));
+    GPR_ASSERT(GRPC_ERROR_NONE == grpc_chttp2_hpack_parser_parse(&p, slice));
   }
   while (state.KeepRunning()) {
     for (auto slice : benchmark_slices) {
-      GPR_ASSERT(GRPC_ERROR_NONE ==
-                 grpc_chttp2_hpack_parser_parse(&exec_ctx, &p, slice));
+      GPR_ASSERT(GRPC_ERROR_NONE == grpc_chttp2_hpack_parser_parse(&p, slice));
     }
-    grpc_exec_ctx_flush(&exec_ctx);
+    grpc_exec_ctx_flush();
   }
   for (auto slice : init_slices) grpc_slice_unref(slice);
   for (auto slice : benchmark_slices) grpc_slice_unref(slice);
-  grpc_chttp2_hpack_parser_destroy(&exec_ctx, &p);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_chttp2_hpack_parser_destroy(&p);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 
@@ -769,8 +762,7 @@ class RepresentativeServerTrailingMetadata {
 static void free_timeout(void* p) { gpr_free(p); }
 
 // New implementation.
-static void OnHeaderNew(grpc_exec_ctx* exec_ctx, void* user_data,
-                        grpc_mdelem md) {
+static void OnHeaderNew(void* user_data, grpc_mdelem md) {
   if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_TIMEOUT)) {
     grpc_millis* cached_timeout =
         static_cast<grpc_millis*>(grpc_mdelem_get_user_data(md, free_timeout));
@@ -793,7 +785,7 @@ static void OnHeaderNew(grpc_exec_ctx* exec_ctx, void* user_data,
       }
     }
     benchmark::DoNotOptimize(timeout);
-    GRPC_MDELEM_UNREF(exec_ctx, md);
+    GRPC_MDELEM_UNREF(md);
   } else {
     GPR_ASSERT(0);
   }
diff --git a/test/cpp/microbenchmarks/bm_chttp2_transport.cc b/test/cpp/microbenchmarks/bm_chttp2_transport.cc
index 154cc917785..a32b841501e 100644
--- a/test/cpp/microbenchmarks/bm_chttp2_transport.cc
+++ b/test/cpp/microbenchmarks/bm_chttp2_transport.cc
@@ -58,7 +58,7 @@ class DummyEndpoint : public grpc_endpoint {
     ru_ = grpc_resource_user_create(Library::get().rq(), "dummy_endpoint");
   }
 
-  void PushInput(grpc_exec_ctx* exec_ctx, grpc_slice slice) {
+  void PushInput(grpc_slice slice) {
     if (read_cb_ == nullptr) {
       GPR_ASSERT(!have_slice_);
       buffered_slice_ = slice;
@@ -66,7 +66,7 @@ class DummyEndpoint : public grpc_endpoint {
       return;
     }
     grpc_slice_buffer_add(slices_, slice);
-    GRPC_CLOSURE_SCHED(exec_ctx, read_cb_, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(read_cb_, GRPC_ERROR_NONE);
     read_cb_ = nullptr;
   }
 
@@ -77,50 +77,45 @@ class DummyEndpoint : public grpc_endpoint {
   bool have_slice_ = false;
   grpc_slice buffered_slice_;
 
-  void QueueRead(grpc_exec_ctx* exec_ctx, grpc_slice_buffer* slices,
-                 grpc_closure* cb) {
+  void QueueRead(grpc_slice_buffer* slices, grpc_closure* cb) {
     GPR_ASSERT(read_cb_ == nullptr);
     if (have_slice_) {
       have_slice_ = false;
       grpc_slice_buffer_add(slices, buffered_slice_);
-      GRPC_CLOSURE_SCHED(exec_ctx, cb, GRPC_ERROR_NONE);
+      GRPC_CLOSURE_SCHED(cb, GRPC_ERROR_NONE);
       return;
     }
     read_cb_ = cb;
     slices_ = slices;
   }
 
-  static void read(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
-                   grpc_slice_buffer* slices, grpc_closure* cb) {
-    static_cast<DummyEndpoint*>(ep)->QueueRead(exec_ctx, slices, cb);
+  static void read(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                   grpc_closure* cb) {
+    static_cast<DummyEndpoint*>(ep)->QueueRead(slices, cb);
   }
 
-  static void write(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
-                    grpc_slice_buffer* slices, grpc_closure* cb) {
-    GRPC_CLOSURE_SCHED(exec_ctx, cb, GRPC_ERROR_NONE);
+  static void write(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                    grpc_closure* cb) {
+    GRPC_CLOSURE_SCHED(cb, GRPC_ERROR_NONE);
   }
 
   static grpc_workqueue* get_workqueue(grpc_endpoint* ep) { return NULL; }
 
-  static void add_to_pollset(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
-                             grpc_pollset* pollset) {}
+  static void add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset) {}
 
-  static void add_to_pollset_set(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
-                                 grpc_pollset_set* pollset) {}
+  static void add_to_pollset_set(grpc_endpoint* ep, grpc_pollset_set* pollset) {
+  }
 
-  static void delete_from_pollset_set(grpc_exec_ctx* exec_ctx,
-                                      grpc_endpoint* ep,
+  static void delete_from_pollset_set(grpc_endpoint* ep,
                                       grpc_pollset_set* pollset) {}
 
-  static void shutdown(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
-                       grpc_error* why) {
-    grpc_resource_user_shutdown(exec_ctx, static_cast<DummyEndpoint*>(ep)->ru_);
-    GRPC_CLOSURE_SCHED(exec_ctx, static_cast<DummyEndpoint*>(ep)->read_cb_,
-                       why);
+  static void shutdown(grpc_endpoint* ep, grpc_error* why) {
+    grpc_resource_user_shutdown(static_cast<DummyEndpoint*>(ep)->ru_);
+    GRPC_CLOSURE_SCHED(static_cast<DummyEndpoint*>(ep)->read_cb_, why);
   }
 
-  static void destroy(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep) {
-    grpc_resource_user_unref(exec_ctx, static_cast<DummyEndpoint*>(ep)->ru_);
+  static void destroy(grpc_endpoint* ep) {
+    grpc_resource_user_unref(static_cast<DummyEndpoint*>(ep)->ru_);
     delete static_cast<DummyEndpoint*>(ep);
   }
 
@@ -136,29 +131,28 @@ class Fixture {
   Fixture(const grpc::ChannelArguments& args, bool client) {
     grpc_channel_args c_args = args.c_channel_args();
     ep_ = new DummyEndpoint;
-    t_ = grpc_create_chttp2_transport(exec_ctx(), &c_args, ep_, client);
-    grpc_chttp2_transport_start_reading(exec_ctx(), t_, NULL);
+    t_ = grpc_create_chttp2_transport(&c_args, ep_, client);
+    grpc_chttp2_transport_start_reading(t_, NULL);
     FlushExecCtx();
   }
 
-  void FlushExecCtx() { grpc_exec_ctx_flush(&exec_ctx_); }
+  void FlushExecCtx() { grpc_exec_ctx_flush(); }
 
   ~Fixture() {
-    grpc_transport_destroy(&exec_ctx_, t_);
-    grpc_exec_ctx_finish(&exec_ctx_);
+    grpc_transport_destroy(t_);
+    grpc_exec_ctx_finish();
   }
 
   grpc_chttp2_transport* chttp2_transport() {
     return reinterpret_cast<grpc_chttp2_transport*>(t_);
   }
   grpc_transport* transport() { return t_; }
-  grpc_exec_ctx* exec_ctx() { return &exec_ctx_; }
 
-  void PushInput(grpc_slice slice) { ep_->PushInput(exec_ctx(), slice); }
+  void PushInput(grpc_slice slice) { ep_->PushInput(slice); }
 
  private:
   DummyEndpoint* ep_;
-  grpc_exec_ctx exec_ctx_ = GRPC_EXEC_CTX_INIT;
+  grpc_exec_ctx _local_exec_ctx;
   grpc_transport* t_;
 };
 
@@ -175,8 +169,8 @@ std::unique_ptr<Closure> MakeClosure(
       GRPC_CLOSURE_INIT(this, Execute, this, sched);
     }
     F f_;
-    static void Execute(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
-      static_cast<C*>(arg)->f_(exec_ctx, error);
+    static void Execute(void* arg, grpc_error* error) {
+      static_cast<C*>(arg)->f_(error);
     }
   };
   return std::unique_ptr<Closure>(new C(f, sched));
@@ -188,8 +182,8 @@ grpc_closure* MakeOnceClosure(
   struct C : public grpc_closure {
     C(const F& f) : f_(f) {}
     F f_;
-    static void Execute(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
-      static_cast<C*>(arg)->f_(exec_ctx, error);
+    static void Execute(void* arg, grpc_error* error) {
+      static_cast<C*>(arg)->f_(error);
       delete static_cast<C*>(arg);
     }
   };
@@ -220,22 +214,22 @@ class Stream {
       gpr_arena_destroy(arena_);
       arena_ = gpr_arena_create(4096);
     }
-    grpc_transport_init_stream(f_->exec_ctx(), f_->transport(),
+    grpc_transport_init_stream(f_->transport(),
                                static_cast<grpc_stream*>(stream_), &refcount_,
                                NULL, arena_);
   }
 
-  void DestroyThen(grpc_exec_ctx* exec_ctx, grpc_closure* closure) {
+  void DestroyThen(grpc_closure* closure) {
     destroy_closure_ = closure;
 #ifndef NDEBUG
-    grpc_stream_unref(exec_ctx, &refcount_, "DestroyThen");
+    grpc_stream_unref(&refcount_, "DestroyThen");
 #else
-    grpc_stream_unref(exec_ctx, &refcount_);
+    grpc_stream_unref(&refcount_);
 #endif
   }
 
-  void Op(grpc_exec_ctx* exec_ctx, grpc_transport_stream_op_batch* op) {
-    grpc_transport_perform_stream_op(exec_ctx, f_->transport(),
+  void Op(grpc_transport_stream_op_batch* op) {
+    grpc_transport_perform_stream_op(f_->transport(),
                                      static_cast<grpc_stream*>(stream_), op);
   }
 
@@ -244,10 +238,9 @@ class Stream {
   }
 
  private:
-  static void FinishDestroy(grpc_exec_ctx* exec_ctx, void* arg,
-                            grpc_error* error) {
+  static void FinishDestroy(void* arg, grpc_error* error) {
     auto stream = static_cast<Stream*>(arg);
-    grpc_transport_destroy_stream(exec_ctx, stream->f_->transport(),
+    grpc_transport_destroy_stream(stream->f_->transport(),
                                   static_cast<grpc_stream*>(stream->stream_),
                                   stream->destroy_closure_);
     gpr_event_set(&stream->done_, (void*)1);
@@ -276,14 +269,13 @@ static void BM_StreamCreateDestroy(benchmark::State& state) {
   op.cancel_stream = true;
   op.payload = &op_payload;
   op_payload.cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
-  std::unique_ptr<Closure> next =
-      MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
-        if (!state.KeepRunning()) return;
-        s.Init(state);
-        s.Op(exec_ctx, &op);
-        s.DestroyThen(exec_ctx, next.get());
-      });
-  GRPC_CLOSURE_RUN(f.exec_ctx(), next.get(), GRPC_ERROR_NONE);
+  std::unique_ptr<Closure> next = MakeClosure([&](grpc_error* error) {
+    if (!state.KeepRunning()) return;
+    s.Init(state);
+    s.Op(&op);
+    s.DestroyThen(next.get());
+  });
+  GRPC_CLOSURE_RUN(next.get(), GRPC_ERROR_NONE);
   f.FlushExecCtx();
   track_counters.Finish(state);
 }
@@ -291,21 +283,21 @@ BENCHMARK(BM_StreamCreateDestroy);
 
 class RepresentativeClientInitialMetadata {
  public:
-  static std::vector<grpc_mdelem> GetElems(grpc_exec_ctx* exec_ctx) {
+  static std::vector<grpc_mdelem> GetElems() {
     return {
         GRPC_MDELEM_SCHEME_HTTP,
         GRPC_MDELEM_METHOD_POST,
         grpc_mdelem_from_slices(
-            exec_ctx, GRPC_MDSTR_PATH,
+            GRPC_MDSTR_PATH,
             grpc_slice_intern(grpc_slice_from_static_string("/foo/bar"))),
-        grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_AUTHORITY,
+        grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY,
                                 grpc_slice_intern(grpc_slice_from_static_string(
                                     "foo.test.google.fr:1234"))),
         GRPC_MDELEM_GRPC_ACCEPT_ENCODING_IDENTITY_COMMA_DEFLATE_COMMA_GZIP,
         GRPC_MDELEM_TE_TRAILERS,
         GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
         grpc_mdelem_from_slices(
-            exec_ctx, GRPC_MDSTR_USER_AGENT,
+            GRPC_MDSTR_USER_AGENT,
             grpc_slice_intern(grpc_slice_from_static_string(
                 "grpc-c/3.0.0-dev (linux; chttp2; green)")))};
   }
@@ -330,34 +322,33 @@ static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State& state) {
   grpc_metadata_batch b;
   grpc_metadata_batch_init(&b);
   b.deadline = GRPC_MILLIS_INF_FUTURE;
-  std::vector<grpc_mdelem> elems = Metadata::GetElems(f.exec_ctx());
+  std::vector<grpc_mdelem> elems = Metadata::GetElems();
   std::vector<grpc_linked_mdelem> storage(elems.size());
   for (size_t i = 0; i < elems.size(); i++) {
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
-        "addmd",
-        grpc_metadata_batch_add_tail(f.exec_ctx(), &b, &storage[i], elems[i])));
+        "addmd", grpc_metadata_batch_add_tail(&b, &storage[i], elems[i])));
   }
 
   f.FlushExecCtx();
-  start = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
+  start = MakeClosure([&](grpc_error* error) {
     if (!state.KeepRunning()) return;
     s.Init(state);
     reset_op();
     op.on_complete = done.get();
     op.send_initial_metadata = true;
     op.payload->send_initial_metadata.send_initial_metadata = &b;
-    s.Op(exec_ctx, &op);
+    s.Op(&op);
   });
-  done = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
+  done = MakeClosure([&](grpc_error* error) {
     reset_op();
     op.cancel_stream = true;
     op.payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
-    s.Op(exec_ctx, &op);
-    s.DestroyThen(exec_ctx, start.get());
+    s.Op(&op);
+    s.DestroyThen(start.get());
   });
-  GRPC_CLOSURE_SCHED(f.exec_ctx(), start.get(), GRPC_ERROR_NONE);
+  GRPC_CLOSURE_SCHED(start.get(), GRPC_ERROR_NONE);
   f.FlushExecCtx();
-  grpc_metadata_batch_destroy(f.exec_ctx(), &b);
+  grpc_metadata_batch_destroy(&b);
   track_counters.Finish(state);
 }
 BENCHMARK_TEMPLATE(BM_StreamCreateSendInitialMetadataDestroy,
@@ -375,21 +366,19 @@ static void BM_TransportEmptyOp(benchmark::State& state) {
     memset(&op, 0, sizeof(op));
     op.payload = &op_payload;
   };
-  std::unique_ptr<Closure> c =
-      MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
-        if (!state.KeepRunning()) return;
-        reset_op();
-        op.on_complete = c.get();
-        s.Op(exec_ctx, &op);
-      });
-  GRPC_CLOSURE_SCHED(f.exec_ctx(), c.get(), GRPC_ERROR_NONE);
+  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* error) {
+    if (!state.KeepRunning()) return;
+    reset_op();
+    op.on_complete = c.get();
+    s.Op(&op);
+  });
+  GRPC_CLOSURE_SCHED(c.get(), GRPC_ERROR_NONE);
   f.FlushExecCtx();
   reset_op();
   op.cancel_stream = true;
   op_payload.cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
-  s.Op(f.exec_ctx(), &op);
-  s.DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx* exec_ctx,
-                                                 grpc_error* error) {}));
+  s.Op(&op);
+  s.DestroyThen(MakeOnceClosure([](grpc_error* error) {}));
   f.FlushExecCtx();
   track_counters.Finish(state);
 }
@@ -420,39 +409,37 @@ static void BM_TransportStreamSend(benchmark::State& state) {
   grpc_metadata_batch_init(&b);
   b.deadline = GRPC_MILLIS_INF_FUTURE;
   std::vector<grpc_mdelem> elems =
-      RepresentativeClientInitialMetadata::GetElems(f.exec_ctx());
+      RepresentativeClientInitialMetadata::GetElems();
   std::vector<grpc_linked_mdelem> storage(elems.size());
   for (size_t i = 0; i < elems.size(); i++) {
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
-        "addmd",
-        grpc_metadata_batch_add_tail(f.exec_ctx(), &b, &storage[i], elems[i])));
+        "addmd", grpc_metadata_batch_add_tail(&b, &storage[i], elems[i])));
   }
 
   gpr_event* bm_done = new gpr_event;
   gpr_event_init(bm_done);
 
-  std::unique_ptr<Closure> c =
-      MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
-        if (!state.KeepRunning()) {
-          gpr_event_set(bm_done, (void*)1);
-          return;
-        }
-        // force outgoing window to be yuge
-        s->chttp2_stream()->flow_control->TestOnlyForceHugeWindow();
-        f.chttp2_transport()->flow_control->TestOnlyForceHugeWindow();
-        grpc_slice_buffer_stream_init(&send_stream, &send_buffer, 0);
-        reset_op();
-        op.on_complete = c.get();
-        op.send_message = true;
-        op.payload->send_message.send_message = &send_stream.base;
-        s->Op(exec_ctx, &op);
-      });
+  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* error) {
+    if (!state.KeepRunning()) {
+      gpr_event_set(bm_done, (void*)1);
+      return;
+    }
+    // force outgoing window to be yuge
+    s->chttp2_stream()->flow_control->TestOnlyForceHugeWindow();
+    f.chttp2_transport()->flow_control->TestOnlyForceHugeWindow();
+    grpc_slice_buffer_stream_init(&send_stream, &send_buffer, 0);
+    reset_op();
+    op.on_complete = c.get();
+    op.send_message = true;
+    op.payload->send_message.send_message = &send_stream.base;
+    s->Op(&op);
+  });
 
   reset_op();
   op.send_initial_metadata = true;
   op.payload->send_initial_metadata.send_initial_metadata = &b;
   op.on_complete = c.get();
-  s->Op(f.exec_ctx(), &op);
+  s->Op(&op);
 
   f.FlushExecCtx();
   gpr_event_wait(bm_done, gpr_inf_future(GPR_CLOCK_REALTIME));
@@ -461,13 +448,12 @@ static void BM_TransportStreamSend(benchmark::State& state) {
   reset_op();
   op.cancel_stream = true;
   op.payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
-  s->Op(f.exec_ctx(), &op);
-  s->DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx* exec_ctx,
-                                                  grpc_error* error) {}));
+  s->Op(&op);
+  s->DestroyThen(MakeOnceClosure([](grpc_error* error) {}));
   f.FlushExecCtx();
   s.reset();
   track_counters.Finish(state);
-  grpc_metadata_batch_destroy(f.exec_ctx(), &b);
+  grpc_metadata_batch_destroy(&b);
   grpc_slice_buffer_destroy(&send_buffer);
 }
 BENCHMARK(BM_TransportStreamSend)->Range(0, 128 * 1024 * 1024);
@@ -551,16 +537,14 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
   grpc_metadata_batch_init(&b_recv);
   b.deadline = GRPC_MILLIS_INF_FUTURE;
   std::vector<grpc_mdelem> elems =
-      RepresentativeClientInitialMetadata::GetElems(f.exec_ctx());
+      RepresentativeClientInitialMetadata::GetElems();
   std::vector<grpc_linked_mdelem> storage(elems.size());
   for (size_t i = 0; i < elems.size(); i++) {
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
-        "addmd",
-        grpc_metadata_batch_add_tail(f.exec_ctx(), &b, &storage[i], elems[i])));
+        "addmd", grpc_metadata_batch_add_tail(&b, &storage[i], elems[i])));
   }
 
-  std::unique_ptr<Closure> do_nothing =
-      MakeClosure([](grpc_exec_ctx* exec_ctx, grpc_error* error) {});
+  std::unique_ptr<Closure> do_nothing = MakeClosure([](grpc_error* error) {});
 
   uint32_t received;
 
@@ -569,51 +553,49 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
   std::unique_ptr<Closure> drain_continue;
   grpc_slice recv_slice;
 
-  std::unique_ptr<Closure> c =
-      MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
-        if (!state.KeepRunning()) return;
-        // force outgoing window to be yuge
-        s.chttp2_stream()->flow_control->TestOnlyForceHugeWindow();
-        f.chttp2_transport()->flow_control->TestOnlyForceHugeWindow();
-        received = 0;
-        reset_op();
-        op.on_complete = do_nothing.get();
-        op.recv_message = true;
-        op.payload->recv_message.recv_message = &recv_stream;
-        op.payload->recv_message.recv_message_ready = drain_start.get();
-        s.Op(exec_ctx, &op);
-        f.PushInput(grpc_slice_ref(incoming_data));
-      });
-
-  drain_start = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
+  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* error) {
+    if (!state.KeepRunning()) return;
+    // force outgoing window to be yuge
+    s.chttp2_stream()->flow_control->TestOnlyForceHugeWindow();
+    f.chttp2_transport()->flow_control->TestOnlyForceHugeWindow();
+    received = 0;
+    reset_op();
+    op.on_complete = do_nothing.get();
+    op.recv_message = true;
+    op.payload->recv_message.recv_message = &recv_stream;
+    op.payload->recv_message.recv_message_ready = drain_start.get();
+    s.Op(&op);
+    f.PushInput(grpc_slice_ref(incoming_data));
+  });
+
+  drain_start = MakeClosure([&](grpc_error* error) {
     if (recv_stream == NULL) {
       GPR_ASSERT(!state.KeepRunning());
       return;
     }
-    GRPC_CLOSURE_RUN(exec_ctx, drain.get(), GRPC_ERROR_NONE);
+    GRPC_CLOSURE_RUN(drain.get(), GRPC_ERROR_NONE);
   });
 
-  drain = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
+  drain = MakeClosure([&](grpc_error* error) {
     do {
       if (received == recv_stream->length) {
-        grpc_byte_stream_destroy(exec_ctx, recv_stream);
-        GRPC_CLOSURE_SCHED(exec_ctx, c.get(), GRPC_ERROR_NONE);
+        grpc_byte_stream_destroy(recv_stream);
+        GRPC_CLOSURE_SCHED(c.get(), GRPC_ERROR_NONE);
         return;
       }
-    } while (grpc_byte_stream_next(exec_ctx, recv_stream,
-                                   recv_stream->length - received,
+    } while (grpc_byte_stream_next(recv_stream, recv_stream->length - received,
                                    drain_continue.get()) &&
              GRPC_ERROR_NONE ==
-                 grpc_byte_stream_pull(exec_ctx, recv_stream, &recv_slice) &&
+                 grpc_byte_stream_pull(recv_stream, &recv_slice) &&
              (received += GRPC_SLICE_LENGTH(recv_slice),
-              grpc_slice_unref_internal(exec_ctx, recv_slice), true));
+              grpc_slice_unref_internal(recv_slice), true));
   });
 
-  drain_continue = MakeClosure([&](grpc_exec_ctx* exec_ctx, grpc_error* error) {
-    grpc_byte_stream_pull(exec_ctx, recv_stream, &recv_slice);
+  drain_continue = MakeClosure([&](grpc_error* error) {
+    grpc_byte_stream_pull(recv_stream, &recv_slice);
     received += GRPC_SLICE_LENGTH(recv_slice);
-    grpc_slice_unref_internal(exec_ctx, recv_slice);
-    GRPC_CLOSURE_RUN(exec_ctx, drain.get(), GRPC_ERROR_NONE);
+    grpc_slice_unref_internal(recv_slice);
+    GRPC_CLOSURE_RUN(drain.get(), GRPC_ERROR_NONE);
   });
 
   reset_op();
@@ -624,7 +606,7 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
   op.payload->recv_initial_metadata.recv_initial_metadata_ready =
       do_nothing.get();
   op.on_complete = c.get();
-  s.Op(f.exec_ctx(), &op);
+  s.Op(&op);
   f.PushInput(SLICE_FROM_BUFFER(
       "\x00\x00\x00\x04\x00\x00\x00\x00\x00"
       // Generated using:
@@ -642,13 +624,12 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
   reset_op();
   op.cancel_stream = true;
   op.payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
-  s.Op(f.exec_ctx(), &op);
-  s.DestroyThen(f.exec_ctx(), MakeOnceClosure([](grpc_exec_ctx* exec_ctx,
-                                                 grpc_error* error) {}));
+  s.Op(&op);
+  s.DestroyThen(MakeOnceClosure([](grpc_error* error) {}));
   f.FlushExecCtx();
   track_counters.Finish(state);
-  grpc_metadata_batch_destroy(f.exec_ctx(), &b);
-  grpc_metadata_batch_destroy(f.exec_ctx(), &b_recv);
+  grpc_metadata_batch_destroy(&b);
+  grpc_metadata_batch_destroy(&b_recv);
   grpc_slice_unref(incoming_data);
 }
 BENCHMARK(BM_TransportStreamRecv)->Range(0, 128 * 1024 * 1024);
diff --git a/test/cpp/microbenchmarks/bm_closure.cc b/test/cpp/microbenchmarks/bm_closure.cc
index a09475b2d11..0e25c3d235d 100644
--- a/test/cpp/microbenchmarks/bm_closure.cc
+++ b/test/cpp/microbenchmarks/bm_closure.cc
@@ -35,7 +35,7 @@ static void BM_NoOpExecCtx(benchmark::State& state) {
   TrackCounters track_counters;
   while (state.KeepRunning()) {
     ExecCtx _local_exec_ctx;
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_exec_ctx_finish();
   }
   track_counters.Finish(state);
 }
@@ -45,14 +45,14 @@ static void BM_WellFlushed(benchmark::State& state) {
   TrackCounters track_counters;
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    grpc_exec_ctx_flush(&exec_ctx);
+    grpc_exec_ctx_flush();
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_WellFlushed);
 
-static void DoNothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
+static void DoNothing(void* arg, grpc_error* error) {}
 
 static void BM_ClosureInitAgainstExecCtx(benchmark::State& state) {
   TrackCounters track_counters;
@@ -74,8 +74,8 @@ static void BM_ClosureInitAgainstCombiner(benchmark::State& state) {
     benchmark::DoNotOptimize(GRPC_CLOSURE_INIT(
         &c, DoNothing, NULL, grpc_combiner_scheduler(combiner)));
   }
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner, "finished");
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_COMBINER_UNREF(combiner, "finished");
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureInitAgainstCombiner);
@@ -86,10 +86,10 @@ static void BM_ClosureRunOnExecCtx(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c, DoNothing, NULL, grpc_schedule_on_exec_ctx);
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_RUN(&exec_ctx, &c, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_RUN(&c, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureRunOnExecCtx);
@@ -99,11 +99,10 @@ static void BM_ClosureCreateAndRun(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_RUN(
-        &exec_ctx,
         GRPC_CLOSURE_CREATE(DoNothing, NULL, grpc_schedule_on_exec_ctx),
         GRPC_ERROR_NONE);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureCreateAndRun);
@@ -114,11 +113,10 @@ static void BM_ClosureInitAndRun(benchmark::State& state) {
   grpc_closure c;
   while (state.KeepRunning()) {
     GRPC_CLOSURE_RUN(
-        &exec_ctx,
         GRPC_CLOSURE_INIT(&c, DoNothing, NULL, grpc_schedule_on_exec_ctx),
         GRPC_ERROR_NONE);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureInitAndRun);
@@ -129,10 +127,10 @@ static void BM_ClosureSchedOnExecCtx(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c, DoNothing, NULL, grpc_schedule_on_exec_ctx);
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_SCHED(&c, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureSchedOnExecCtx);
@@ -145,11 +143,11 @@ static void BM_ClosureSched2OnExecCtx(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_schedule_on_exec_ctx);
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c2, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_SCHED(&c1, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c2, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureSched2OnExecCtx);
@@ -164,12 +162,12 @@ static void BM_ClosureSched3OnExecCtx(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c3, DoNothing, NULL, grpc_schedule_on_exec_ctx);
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c2, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c3, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_SCHED(&c1, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c2, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c3, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureSched3OnExecCtx);
@@ -182,10 +180,10 @@ static void BM_AcquireMutex(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
     gpr_mu_lock(&mu);
-    DoNothing(&exec_ctx, NULL, GRPC_ERROR_NONE);
+    DoNothing(NULL, GRPC_ERROR_NONE);
     gpr_mu_unlock(&mu);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_AcquireMutex);
@@ -198,13 +196,13 @@ static void BM_TryAcquireMutex(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
     if (gpr_mu_trylock(&mu)) {
-      DoNothing(&exec_ctx, NULL, GRPC_ERROR_NONE);
+      DoNothing(NULL, GRPC_ERROR_NONE);
       gpr_mu_unlock(&mu);
     } else {
       abort();
     }
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_TryAcquireMutex);
@@ -216,10 +214,10 @@ static void BM_AcquireSpinlock(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
     gpr_spinlock_lock(&mu);
-    DoNothing(&exec_ctx, NULL, GRPC_ERROR_NONE);
+    DoNothing(NULL, GRPC_ERROR_NONE);
     gpr_spinlock_unlock(&mu);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_AcquireSpinlock);
@@ -231,13 +229,13 @@ static void BM_TryAcquireSpinlock(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
     if (gpr_spinlock_trylock(&mu)) {
-      DoNothing(&exec_ctx, NULL, GRPC_ERROR_NONE);
+      DoNothing(NULL, GRPC_ERROR_NONE);
       gpr_spinlock_unlock(&mu);
     } else {
       abort();
     }
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_TryAcquireSpinlock);
@@ -249,11 +247,11 @@ static void BM_ClosureSchedOnCombiner(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c, DoNothing, NULL, grpc_combiner_scheduler(combiner));
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_SCHED(&c, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner, "finished");
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_COMBINER_UNREF(combiner, "finished");
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureSchedOnCombiner);
@@ -267,12 +265,12 @@ static void BM_ClosureSched2OnCombiner(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner));
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c2, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_SCHED(&c1, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c2, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner, "finished");
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_COMBINER_UNREF(combiner, "finished");
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureSched2OnCombiner);
@@ -288,13 +286,13 @@ static void BM_ClosureSched3OnCombiner(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c3, DoNothing, NULL, grpc_combiner_scheduler(combiner));
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c2, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c3, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_SCHED(&c1, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c2, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c3, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner, "finished");
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_COMBINER_UNREF(combiner, "finished");
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureSched3OnCombiner);
@@ -309,13 +307,13 @@ static void BM_ClosureSched2OnTwoCombiners(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner2));
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c2, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_SCHED(&c1, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c2, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner1, "finished");
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner2, "finished");
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_COMBINER_UNREF(combiner1, "finished");
+  GRPC_COMBINER_UNREF(combiner2, "finished");
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureSched2OnTwoCombiners);
@@ -334,15 +332,15 @@ static void BM_ClosureSched4OnTwoCombiners(benchmark::State& state) {
   GRPC_CLOSURE_INIT(&c4, DoNothing, NULL, grpc_combiner_scheduler(combiner2));
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c1, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c2, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c3, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_SCHED(&exec_ctx, &c4, GRPC_ERROR_NONE);
-    grpc_exec_ctx_flush(&exec_ctx);
+    GRPC_CLOSURE_SCHED(&c1, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c2, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c3, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&c4, GRPC_ERROR_NONE);
+    grpc_exec_ctx_flush();
   }
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner1, "finished");
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner2, "finished");
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_COMBINER_UNREF(combiner1, "finished");
+  GRPC_COMBINER_UNREF(combiner2, "finished");
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureSched4OnTwoCombiners);
@@ -356,13 +354,11 @@ class Rescheduler {
     GRPC_CLOSURE_INIT(&closure_, Step, this, scheduler);
   }
 
-  void ScheduleFirst(grpc_exec_ctx* exec_ctx) {
-    GRPC_CLOSURE_SCHED(exec_ctx, &closure_, GRPC_ERROR_NONE);
-  }
+  void ScheduleFirst() { GRPC_CLOSURE_SCHED(&closure_, GRPC_ERROR_NONE); }
 
   void ScheduleFirstAgainstDifferentScheduler(
-      grpc_exec_ctx* exec_ctx, grpc_closure_scheduler* scheduler) {
-    GRPC_CLOSURE_SCHED(exec_ctx, GRPC_CLOSURE_CREATE(Step, this, scheduler),
+      grpc_closure_scheduler* scheduler) {
+    GRPC_CLOSURE_SCHED(GRPC_CLOSURE_CREATE(Step, this, scheduler),
                        GRPC_ERROR_NONE);
   }
 
@@ -370,10 +366,10 @@ class Rescheduler {
   benchmark::State& state_;
   grpc_closure closure_;
 
-  static void Step(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  static void Step(void* arg, grpc_error* error) {
     Rescheduler* self = static_cast<Rescheduler*>(arg);
     if (self->state_.KeepRunning()) {
-      GRPC_CLOSURE_SCHED(exec_ctx, &self->closure_, GRPC_ERROR_NONE);
+      GRPC_CLOSURE_SCHED(&self->closure_, GRPC_ERROR_NONE);
     }
   }
 };
@@ -382,8 +378,8 @@ static void BM_ClosureReschedOnExecCtx(benchmark::State& state) {
   TrackCounters track_counters;
   ExecCtx _local_exec_ctx;
   Rescheduler r(state, grpc_schedule_on_exec_ctx);
-  r.ScheduleFirst(&exec_ctx);
-  grpc_exec_ctx_finish(&exec_ctx);
+  r.ScheduleFirst();
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureReschedOnExecCtx);
@@ -393,10 +389,10 @@ static void BM_ClosureReschedOnCombiner(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   grpc_combiner* combiner = grpc_combiner_create();
   Rescheduler r(state, grpc_combiner_scheduler(combiner));
-  r.ScheduleFirst(&exec_ctx);
-  grpc_exec_ctx_flush(&exec_ctx);
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner, "finished");
-  grpc_exec_ctx_finish(&exec_ctx);
+  r.ScheduleFirst();
+  grpc_exec_ctx_flush();
+  GRPC_COMBINER_UNREF(combiner, "finished");
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureReschedOnCombiner);
@@ -406,11 +402,10 @@ static void BM_ClosureReschedOnCombinerFinally(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   grpc_combiner* combiner = grpc_combiner_create();
   Rescheduler r(state, grpc_combiner_finally_scheduler(combiner));
-  r.ScheduleFirstAgainstDifferentScheduler(&exec_ctx,
-                                           grpc_combiner_scheduler(combiner));
-  grpc_exec_ctx_flush(&exec_ctx);
-  GRPC_COMBINER_UNREF(&exec_ctx, combiner, "finished");
-  grpc_exec_ctx_finish(&exec_ctx);
+  r.ScheduleFirstAgainstDifferentScheduler(grpc_combiner_scheduler(combiner));
+  grpc_exec_ctx_flush();
+  GRPC_COMBINER_UNREF(combiner, "finished");
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_ClosureReschedOnCombinerFinally);
diff --git a/test/cpp/microbenchmarks/bm_cq.cc b/test/cpp/microbenchmarks/bm_cq.cc
index 8cf7823a94d..6d36e61cff9 100644
--- a/test/cpp/microbenchmarks/bm_cq.cc
+++ b/test/cpp/microbenchmarks/bm_cq.cc
@@ -65,7 +65,7 @@ static void BM_CreateDestroyCore(benchmark::State& state) {
 }
 BENCHMARK(BM_CreateDestroyCore);
 
-static void DoneWithCompletionOnStack(grpc_exec_ctx* exec_ctx, void* arg,
+static void DoneWithCompletionOnStack(void* arg,
                                       grpc_cq_completion* completion) {}
 
 class DummyTag final : public internal::CompletionQueueTag {
@@ -82,9 +82,9 @@ static void BM_Pass1Cpp(benchmark::State& state) {
     DummyTag dummy_tag;
     ExecCtx _local_exec_ctx;
     GPR_ASSERT(grpc_cq_begin_op(c_cq, &dummy_tag));
-    grpc_cq_end_op(&exec_ctx, c_cq, &dummy_tag, GRPC_ERROR_NONE,
-                   DoneWithCompletionOnStack, NULL, &completion);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_cq_end_op(c_cq, &dummy_tag, GRPC_ERROR_NONE, DoneWithCompletionOnStack,
+                   NULL, &completion);
+    grpc_exec_ctx_finish();
     void* tag;
     bool ok;
     cq.Next(&tag, &ok);
@@ -102,9 +102,9 @@ static void BM_Pass1Core(benchmark::State& state) {
     grpc_cq_completion completion;
     ExecCtx _local_exec_ctx;
     GPR_ASSERT(grpc_cq_begin_op(cq, NULL));
-    grpc_cq_end_op(&exec_ctx, cq, NULL, GRPC_ERROR_NONE,
-                   DoneWithCompletionOnStack, NULL, &completion);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_cq_end_op(cq, NULL, GRPC_ERROR_NONE, DoneWithCompletionOnStack, NULL,
+                   &completion);
+    grpc_exec_ctx_finish();
     grpc_completion_queue_next(cq, deadline, NULL);
   }
   grpc_completion_queue_destroy(cq);
@@ -121,9 +121,9 @@ static void BM_Pluck1Core(benchmark::State& state) {
     grpc_cq_completion completion;
     ExecCtx _local_exec_ctx;
     GPR_ASSERT(grpc_cq_begin_op(cq, NULL));
-    grpc_cq_end_op(&exec_ctx, cq, NULL, GRPC_ERROR_NONE,
-                   DoneWithCompletionOnStack, NULL, &completion);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_cq_end_op(cq, NULL, GRPC_ERROR_NONE, DoneWithCompletionOnStack, NULL,
+                   &completion);
+    grpc_exec_ctx_finish();
     grpc_completion_queue_pluck(cq, NULL, deadline, NULL);
   }
   grpc_completion_queue_destroy(cq);
diff --git a/test/cpp/microbenchmarks/bm_cq_multiple_threads.cc b/test/cpp/microbenchmarks/bm_cq_multiple_threads.cc
index 8d4349a297e..41e616a6ef0 100644
--- a/test/cpp/microbenchmarks/bm_cq_multiple_threads.cc
+++ b/test/cpp/microbenchmarks/bm_cq_multiple_threads.cc
@@ -43,9 +43,8 @@ static grpc_completion_queue* g_cq;
 static grpc_event_engine_vtable g_vtable;
 static const grpc_event_engine_vtable* g_old_vtable;
 
-static void pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* ps,
-                             grpc_closure* closure) {
-  GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_ERROR_NONE);
+static void pollset_shutdown(grpc_pollset* ps, grpc_closure* closure) {
+  GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
 }
 
 static void pollset_init(grpc_pollset* ps, gpr_mu** mu) {
@@ -53,25 +52,20 @@ static void pollset_init(grpc_pollset* ps, gpr_mu** mu) {
   *mu = &ps->mu;
 }
 
-static void pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* ps) {
-  gpr_mu_destroy(&ps->mu);
-}
+static void pollset_destroy(grpc_pollset* ps) { gpr_mu_destroy(&ps->mu); }
 
-static grpc_error* pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
-                                grpc_pollset_worker* worker) {
+static grpc_error* pollset_kick(grpc_pollset* p, grpc_pollset_worker* worker) {
   return GRPC_ERROR_NONE;
 }
 
 /* Callback when the tag is dequeued from the completion queue. Does nothing */
-static void cq_done_cb(grpc_exec_ctx* exec_ctx, void* done_arg,
-                       grpc_cq_completion* cq_completion) {
+static void cq_done_cb(void* done_arg, grpc_cq_completion* cq_completion) {
   gpr_free(cq_completion);
 }
 
 /* Queues a completion tag if deadline is > 0.
  * Does nothing if deadline is 0 (i.e gpr_time_0(GPR_CLOCK_MONOTONIC)) */
-static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* ps,
-                                grpc_pollset_worker** worker,
+static grpc_error* pollset_work(grpc_pollset* ps, grpc_pollset_worker** worker,
                                 grpc_millis deadline) {
   if (deadline == 0) {
     gpr_log(GPR_DEBUG, "no-op");
@@ -80,9 +74,9 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* ps,
 
   gpr_mu_unlock(&ps->mu);
   GPR_ASSERT(grpc_cq_begin_op(g_cq, g_tag));
-  grpc_cq_end_op(exec_ctx, g_cq, g_tag, GRPC_ERROR_NONE, cq_done_cb, NULL,
+  grpc_cq_end_op(g_cq, g_tag, GRPC_ERROR_NONE, cq_done_cb, NULL,
                  (grpc_cq_completion*)gpr_malloc(sizeof(grpc_cq_completion)));
-  grpc_exec_ctx_flush(exec_ctx);
+  grpc_exec_ctx_flush();
   gpr_mu_lock(&ps->mu);
   return GRPC_ERROR_NONE;
 }
diff --git a/test/cpp/microbenchmarks/bm_error.cc b/test/cpp/microbenchmarks/bm_error.cc
index b9b3960f859..3f85e351f56 100644
--- a/test/cpp/microbenchmarks/bm_error.cc
+++ b/test/cpp/microbenchmarks/bm_error.cc
@@ -250,10 +250,10 @@ static void BM_ErrorGetStatus(benchmark::State& state) {
   while (state.KeepRunning()) {
     grpc_status_code status;
     grpc_slice slice;
-    grpc_error_get_status(&exec_ctx, fixture.error(), fixture.deadline(),
-                          &status, &slice, NULL);
+    grpc_error_get_status(fixture.error(), fixture.deadline(), &status, &slice,
+                          NULL);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 
@@ -264,10 +264,10 @@ static void BM_ErrorGetStatusCode(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
     grpc_status_code status;
-    grpc_error_get_status(&exec_ctx, fixture.error(), fixture.deadline(),
-                          &status, NULL, NULL);
+    grpc_error_get_status(fixture.error(), fixture.deadline(), &status, NULL,
+                          NULL);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 
@@ -278,10 +278,10 @@ static void BM_ErrorHttpError(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
     grpc_http2_error_code error;
-    grpc_error_get_status(&exec_ctx, fixture.error(), fixture.deadline(), NULL,
-                          NULL, &error);
+    grpc_error_get_status(fixture.error(), fixture.deadline(), NULL, NULL,
+                          &error);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 
diff --git a/test/cpp/microbenchmarks/bm_fullstack_trickle.cc b/test/cpp/microbenchmarks/bm_fullstack_trickle.cc
index 2680ae61983..74e99982ce8 100644
--- a/test/cpp/microbenchmarks/bm_fullstack_trickle.cc
+++ b/test/cpp/microbenchmarks/bm_fullstack_trickle.cc
@@ -180,10 +180,10 @@ class TrickledCHTTP2 : public EndpointPairFixture {
     ExecCtx _local_exec_ctx;
     inc_time();
     size_t client_backlog =
-        grpc_trickle_endpoint_trickle(&exec_ctx, endpoint_pair_.client);
+        grpc_trickle_endpoint_trickle(endpoint_pair_.client);
     size_t server_backlog =
-        grpc_trickle_endpoint_trickle(&exec_ctx, endpoint_pair_.server);
-    grpc_exec_ctx_finish(&exec_ctx);
+        grpc_trickle_endpoint_trickle(endpoint_pair_.server);
+    grpc_exec_ctx_finish();
     if (update_stats) {
       UpdateStats((grpc_chttp2_transport*)client_transport_, &client_stats_,
                   client_backlog);
diff --git a/test/cpp/microbenchmarks/bm_metadata.cc b/test/cpp/microbenchmarks/bm_metadata.cc
index f330493de9e..5d89e0d3c6c 100644
--- a/test/cpp/microbenchmarks/bm_metadata.cc
+++ b/test/cpp/microbenchmarks/bm_metadata.cc
@@ -92,9 +92,9 @@ static void BM_MetadataFromNonInternedSlices(benchmark::State& state) {
   gpr_slice v = grpc_slice_from_static_string("value");
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(k, v, NULL));
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_MetadataFromNonInternedSlices);
@@ -105,9 +105,9 @@ static void BM_MetadataFromInternedSlices(benchmark::State& state) {
   gpr_slice v = grpc_slice_intern(grpc_slice_from_static_string("value"));
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(k, v, NULL));
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_slice_unref(k);
   grpc_slice_unref(v);
   track_counters.Finish(state);
@@ -120,12 +120,12 @@ static void BM_MetadataFromInternedSlicesAlreadyInIndex(
   gpr_slice k = grpc_slice_intern(grpc_slice_from_static_string("key"));
   gpr_slice v = grpc_slice_intern(grpc_slice_from_static_string("value"));
   ExecCtx _local_exec_ctx;
-  grpc_mdelem seed = grpc_mdelem_create(&exec_ctx, k, v, NULL);
+  grpc_mdelem seed = grpc_mdelem_create(k, v, NULL);
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(k, v, NULL));
   }
-  GRPC_MDELEM_UNREF(&exec_ctx, seed);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(seed);
+  grpc_exec_ctx_finish();
   grpc_slice_unref(k);
   grpc_slice_unref(v);
   track_counters.Finish(state);
@@ -138,9 +138,9 @@ static void BM_MetadataFromInternedKey(benchmark::State& state) {
   gpr_slice v = grpc_slice_from_static_string("value");
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(k, v, NULL));
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_slice_unref(k);
   track_counters.Finish(state);
 }
@@ -154,12 +154,10 @@ static void BM_MetadataFromNonInternedSlicesWithBackingStore(
   char backing_store[sizeof(grpc_mdelem_data)];
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(
-        &exec_ctx,
-        grpc_mdelem_create(&exec_ctx, k, v,
-                           reinterpret_cast<grpc_mdelem_data*>(backing_store)));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(
+        k, v, reinterpret_cast<grpc_mdelem_data*>(backing_store)));
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_MetadataFromNonInternedSlicesWithBackingStore);
@@ -172,12 +170,10 @@ static void BM_MetadataFromInternedSlicesWithBackingStore(
   char backing_store[sizeof(grpc_mdelem_data)];
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(
-        &exec_ctx,
-        grpc_mdelem_create(&exec_ctx, k, v,
-                           reinterpret_cast<grpc_mdelem_data*>(backing_store)));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(
+        k, v, reinterpret_cast<grpc_mdelem_data*>(backing_store)));
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_slice_unref(k);
   grpc_slice_unref(v);
   track_counters.Finish(state);
@@ -192,12 +188,10 @@ static void BM_MetadataFromInternedKeyWithBackingStore(
   char backing_store[sizeof(grpc_mdelem_data)];
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(
-        &exec_ctx,
-        grpc_mdelem_create(&exec_ctx, k, v,
-                           reinterpret_cast<grpc_mdelem_data*>(backing_store)));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(
+        k, v, reinterpret_cast<grpc_mdelem_data*>(backing_store)));
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_slice_unref(k);
   track_counters.Finish(state);
 }
@@ -209,9 +203,9 @@ static void BM_MetadataFromStaticMetadataStrings(benchmark::State& state) {
   gpr_slice v = GRPC_MDSTR_200;
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(k, v, NULL));
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_slice_unref(k);
   track_counters.Finish(state);
 }
@@ -224,9 +218,9 @@ static void BM_MetadataFromStaticMetadataStringsNotIndexed(
   gpr_slice v = GRPC_MDSTR_GZIP;
   ExecCtx _local_exec_ctx;
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_create(&exec_ctx, k, v, NULL));
+    GRPC_MDELEM_UNREF(grpc_mdelem_create(k, v, NULL));
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_slice_unref(k);
   track_counters.Finish(state);
 }
@@ -236,15 +230,14 @@ static void BM_MetadataRefUnrefExternal(benchmark::State& state) {
   TrackCounters track_counters;
   char backing_store[sizeof(grpc_mdelem_data)];
   ExecCtx _local_exec_ctx;
-  grpc_mdelem el =
-      grpc_mdelem_create(&exec_ctx, grpc_slice_from_static_string("a"),
-                         grpc_slice_from_static_string("b"),
-                         reinterpret_cast<grpc_mdelem_data*>(backing_store));
+  grpc_mdelem el = grpc_mdelem_create(
+      grpc_slice_from_static_string("a"), grpc_slice_from_static_string("b"),
+      reinterpret_cast<grpc_mdelem_data*>(backing_store));
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, GRPC_MDELEM_REF(el));
+    GRPC_MDELEM_UNREF(GRPC_MDELEM_REF(el));
   }
-  GRPC_MDELEM_UNREF(&exec_ctx, el);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(el);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_MetadataRefUnrefExternal);
@@ -256,14 +249,14 @@ static void BM_MetadataRefUnrefInterned(benchmark::State& state) {
   gpr_slice k = grpc_slice_intern(grpc_slice_from_static_string("key"));
   gpr_slice v = grpc_slice_intern(grpc_slice_from_static_string("value"));
   grpc_mdelem el = grpc_mdelem_create(
-      &exec_ctx, k, v, reinterpret_cast<grpc_mdelem_data*>(backing_store));
+      k, v, reinterpret_cast<grpc_mdelem_data*>(backing_store));
   grpc_slice_unref(k);
   grpc_slice_unref(v);
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, GRPC_MDELEM_REF(el));
+    GRPC_MDELEM_UNREF(GRPC_MDELEM_REF(el));
   }
-  GRPC_MDELEM_UNREF(&exec_ctx, el);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(el);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_MetadataRefUnrefInterned);
@@ -271,14 +264,13 @@ BENCHMARK(BM_MetadataRefUnrefInterned);
 static void BM_MetadataRefUnrefAllocated(benchmark::State& state) {
   TrackCounters track_counters;
   ExecCtx _local_exec_ctx;
-  grpc_mdelem el =
-      grpc_mdelem_create(&exec_ctx, grpc_slice_from_static_string("a"),
-                         grpc_slice_from_static_string("b"), NULL);
+  grpc_mdelem el = grpc_mdelem_create(grpc_slice_from_static_string("a"),
+                                      grpc_slice_from_static_string("b"), NULL);
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, GRPC_MDELEM_REF(el));
+    GRPC_MDELEM_UNREF(GRPC_MDELEM_REF(el));
   }
-  GRPC_MDELEM_UNREF(&exec_ctx, el);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(el);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_MetadataRefUnrefAllocated);
@@ -286,13 +278,12 @@ BENCHMARK(BM_MetadataRefUnrefAllocated);
 static void BM_MetadataRefUnrefStatic(benchmark::State& state) {
   TrackCounters track_counters;
   ExecCtx _local_exec_ctx;
-  grpc_mdelem el =
-      grpc_mdelem_create(&exec_ctx, GRPC_MDSTR_STATUS, GRPC_MDSTR_200, NULL);
+  grpc_mdelem el = grpc_mdelem_create(GRPC_MDSTR_STATUS, GRPC_MDSTR_200, NULL);
   while (state.KeepRunning()) {
-    GRPC_MDELEM_UNREF(&exec_ctx, GRPC_MDELEM_REF(el));
+    GRPC_MDELEM_UNREF(GRPC_MDELEM_REF(el));
   }
-  GRPC_MDELEM_UNREF(&exec_ctx, el);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(el);
+  grpc_exec_ctx_finish();
   track_counters.Finish(state);
 }
 BENCHMARK(BM_MetadataRefUnrefStatic);
diff --git a/test/cpp/microbenchmarks/bm_pollset.cc b/test/cpp/microbenchmarks/bm_pollset.cc
index d097f8e32e8..3da8e16788e 100644
--- a/test/cpp/microbenchmarks/bm_pollset.cc
+++ b/test/cpp/microbenchmarks/bm_pollset.cc
@@ -41,8 +41,8 @@
 
 auto& force_library_initialization = Library::get();
 
-static void shutdown_ps(grpc_exec_ctx* exec_ctx, void* ps, grpc_error* error) {
-  grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(ps));
+static void shutdown_ps(void* ps, grpc_error* error) {
+  grpc_pollset_destroy(static_cast<grpc_pollset*>(ps));
 }
 
 static void BM_CreateDestroyPollset(benchmark::State& state) {
@@ -58,11 +58,11 @@ static void BM_CreateDestroyPollset(benchmark::State& state) {
     memset(ps, 0, ps_sz);
     grpc_pollset_init(ps, &mu);
     gpr_mu_lock(mu);
-    grpc_pollset_shutdown(&exec_ctx, ps, &shutdown_ps_closure);
+    grpc_pollset_shutdown(ps, &shutdown_ps_closure);
     gpr_mu_unlock(mu);
-    grpc_exec_ctx_flush(&exec_ctx);
+    grpc_exec_ctx_flush();
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   gpr_free(ps);
   track_counters.Finish(state);
 }
@@ -117,14 +117,14 @@ static void BM_PollEmptyPollset(benchmark::State& state) {
   ExecCtx _local_exec_ctx;
   gpr_mu_lock(mu);
   while (state.KeepRunning()) {
-    GRPC_ERROR_UNREF(grpc_pollset_work(&exec_ctx, ps, NULL, 0));
+    GRPC_ERROR_UNREF(grpc_pollset_work(ps, NULL, 0));
   }
   grpc_closure shutdown_ps_closure;
   GRPC_CLOSURE_INIT(&shutdown_ps_closure, shutdown_ps, ps,
                     grpc_schedule_on_exec_ctx);
-  grpc_pollset_shutdown(&exec_ctx, ps, &shutdown_ps_closure);
+  grpc_pollset_shutdown(ps, &shutdown_ps_closure);
   gpr_mu_unlock(mu);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   gpr_free(ps);
   track_counters.Finish(state);
 }
@@ -142,17 +142,17 @@ static void BM_PollAddFd(benchmark::State& state) {
       GRPC_LOG_IF_ERROR("wakeup_fd_init", grpc_wakeup_fd_init(&wakeup_fd)));
   grpc_fd* fd = grpc_fd_create(wakeup_fd.read_fd, "xxx");
   while (state.KeepRunning()) {
-    grpc_pollset_add_fd(&exec_ctx, ps, fd);
-    grpc_exec_ctx_flush(&exec_ctx);
+    grpc_pollset_add_fd(ps, fd);
+    grpc_exec_ctx_flush();
   }
-  grpc_fd_orphan(&exec_ctx, fd, NULL, NULL, false /* already_closed */, "xxx");
+  grpc_fd_orphan(fd, NULL, NULL, false /* already_closed */, "xxx");
   grpc_closure shutdown_ps_closure;
   GRPC_CLOSURE_INIT(&shutdown_ps_closure, shutdown_ps, ps,
                     grpc_schedule_on_exec_ctx);
   gpr_mu_lock(mu);
-  grpc_pollset_shutdown(&exec_ctx, ps, &shutdown_ps_closure);
+  grpc_pollset_shutdown(ps, &shutdown_ps_closure);
   gpr_mu_unlock(mu);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   gpr_free(ps);
   track_counters.Finish(state);
 }
@@ -169,7 +169,7 @@ Closure* MakeClosure(F f, grpc_closure_scheduler* scheduler) {
     C(F f, grpc_closure_scheduler* scheduler) : f_(f) {
       GRPC_CLOSURE_INIT(this, C::cbfn, this, scheduler);
     }
-    static void cbfn(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+    static void cbfn(void* arg, grpc_error* error) {
       C* p = static_cast<C*>(arg);
       p->f_();
     }
@@ -222,7 +222,7 @@ static void BM_SingleThreadPollOneFd(benchmark::State& state) {
   grpc_wakeup_fd wakeup_fd;
   GRPC_ERROR_UNREF(grpc_wakeup_fd_init(&wakeup_fd));
   grpc_fd* wakeup = grpc_fd_create(wakeup_fd.read_fd, "wakeup_read");
-  grpc_pollset_add_fd(&exec_ctx, ps, wakeup);
+  grpc_pollset_add_fd(ps, wakeup);
   bool done = false;
   Closure* continue_closure = MakeClosure(
       [&]() {
@@ -232,25 +232,23 @@ static void BM_SingleThreadPollOneFd(benchmark::State& state) {
           return;
         }
         GRPC_ERROR_UNREF(grpc_wakeup_fd_wakeup(&wakeup_fd));
-        grpc_fd_notify_on_read(&exec_ctx, wakeup, continue_closure);
+        grpc_fd_notify_on_read(wakeup, continue_closure);
       },
       grpc_schedule_on_exec_ctx);
   GRPC_ERROR_UNREF(grpc_wakeup_fd_wakeup(&wakeup_fd));
-  grpc_fd_notify_on_read(&exec_ctx, wakeup, continue_closure);
+  grpc_fd_notify_on_read(wakeup, continue_closure);
   gpr_mu_lock(mu);
   while (!done) {
-    GRPC_ERROR_UNREF(
-        grpc_pollset_work(&exec_ctx, ps, NULL, GRPC_MILLIS_INF_FUTURE));
+    GRPC_ERROR_UNREF(grpc_pollset_work(ps, NULL, GRPC_MILLIS_INF_FUTURE));
   }
-  grpc_fd_orphan(&exec_ctx, wakeup, NULL, NULL, false /* already_closed */,
-                 "done");
+  grpc_fd_orphan(wakeup, NULL, NULL, false /* already_closed */, "done");
   wakeup_fd.read_fd = 0;
   grpc_closure shutdown_ps_closure;
   GRPC_CLOSURE_INIT(&shutdown_ps_closure, shutdown_ps, ps,
                     grpc_schedule_on_exec_ctx);
-  grpc_pollset_shutdown(&exec_ctx, ps, &shutdown_ps_closure);
+  grpc_pollset_shutdown(ps, &shutdown_ps_closure);
   gpr_mu_unlock(mu);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_wakeup_fd_destroy(&wakeup_fd);
   gpr_free(ps);
   track_counters.Finish(state);
diff --git a/test/cpp/microbenchmarks/fullstack_fixtures.h b/test/cpp/microbenchmarks/fullstack_fixtures.h
index 71bbb393db4..24b74b9d374 100644
--- a/test/cpp/microbenchmarks/fullstack_fixtures.h
+++ b/test/cpp/microbenchmarks/fullstack_fixtures.h
@@ -166,7 +166,7 @@ class EndpointPairFixture : public BaseFixture {
     fixture_configuration.ApplyCommonServerBuilderConfig(&b);
     server_ = b.BuildAndStart();
 
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
 
     /* add server endpoint to server_
      * */
@@ -174,19 +174,19 @@ class EndpointPairFixture : public BaseFixture {
       const grpc_channel_args* server_args =
           grpc_server_get_channel_args(server_->c_server());
       server_transport_ = grpc_create_chttp2_transport(
-          &exec_ctx, server_args, endpoints.server, 0 /* is_client */);
+          server_args, endpoints.server, 0 /* is_client */);
 
       grpc_pollset** pollsets;
       size_t num_pollsets = 0;
       grpc_server_get_pollsets(server_->c_server(), &pollsets, &num_pollsets);
 
       for (size_t i = 0; i < num_pollsets; i++) {
-        grpc_endpoint_add_to_pollset(&exec_ctx, endpoints.server, pollsets[i]);
+        grpc_endpoint_add_to_pollset(endpoints.server, pollsets[i]);
       }
 
-      grpc_server_setup_transport(&exec_ctx, server_->c_server(),
-                                  server_transport_, NULL, server_args);
-      grpc_chttp2_transport_start_reading(&exec_ctx, server_transport_, NULL);
+      grpc_server_setup_transport(server_->c_server(), server_transport_, NULL,
+                                  server_args);
+      grpc_chttp2_transport_start_reading(server_transport_, NULL);
     }
 
     /* create channel */
@@ -197,17 +197,16 @@ class EndpointPairFixture : public BaseFixture {
 
       grpc_channel_args c_args = args.c_channel_args();
       client_transport_ =
-          grpc_create_chttp2_transport(&exec_ctx, &c_args, endpoints.client, 1);
+          grpc_create_chttp2_transport(&c_args, endpoints.client, 1);
       GPR_ASSERT(client_transport_);
-      grpc_channel* channel =
-          grpc_channel_create(&exec_ctx, "target", &c_args,
-                              GRPC_CLIENT_DIRECT_CHANNEL, client_transport_);
-      grpc_chttp2_transport_start_reading(&exec_ctx, client_transport_, NULL);
+      grpc_channel* channel = grpc_channel_create(
+          "target", &c_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport_);
+      grpc_chttp2_transport_start_reading(client_transport_, NULL);
 
       channel_ = CreateChannelInternal("", channel);
     }
 
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_exec_ctx_finish();
   }
 
   virtual ~EndpointPairFixture() {
diff --git a/test/cpp/naming/resolver_component_test.cc b/test/cpp/naming/resolver_component_test.cc
index 120cf6fa9fa..836cc676c23 100644
--- a/test/cpp/naming/resolver_component_test.cc
+++ b/test/cpp/naming/resolver_component_test.cc
@@ -149,32 +149,32 @@ struct ArgsStruct {
   std::string expected_lb_policy;
 };
 
-void ArgsInit(grpc_exec_ctx* exec_ctx, ArgsStruct* args) {
+void ArgsInit(ArgsStruct* args) {
   gpr_event_init(&args->ev);
   args->pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(args->pollset, &args->mu);
   args->pollset_set = grpc_pollset_set_create();
-  grpc_pollset_set_add_pollset(exec_ctx, args->pollset_set, args->pollset);
+  grpc_pollset_set_add_pollset(args->pollset_set, args->pollset);
   args->lock = grpc_combiner_create();
   gpr_atm_rel_store(&args->done_atm, 0);
   args->channel_args = NULL;
 }
 
-void DoNothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
+void DoNothing(void* arg, grpc_error* error) {}
 
-void ArgsFinish(grpc_exec_ctx* exec_ctx, ArgsStruct* args) {
+void ArgsFinish(ArgsStruct* args) {
   GPR_ASSERT(gpr_event_wait(&args->ev, TestDeadline()));
-  grpc_pollset_set_del_pollset(exec_ctx, args->pollset_set, args->pollset);
-  grpc_pollset_set_destroy(exec_ctx, args->pollset_set);
+  grpc_pollset_set_del_pollset(args->pollset_set, args->pollset);
+  grpc_pollset_set_destroy(args->pollset_set);
   grpc_closure DoNothing_cb;
   GRPC_CLOSURE_INIT(&DoNothing_cb, DoNothing, NULL, grpc_schedule_on_exec_ctx);
-  grpc_pollset_shutdown(exec_ctx, args->pollset, &DoNothing_cb);
+  grpc_pollset_shutdown(args->pollset, &DoNothing_cb);
   // exec_ctx needs to be flushed before calling grpc_pollset_destroy()
-  grpc_channel_args_destroy(exec_ctx, args->channel_args);
-  grpc_exec_ctx_flush(exec_ctx);
-  grpc_pollset_destroy(exec_ctx, args->pollset);
+  grpc_channel_args_destroy(args->channel_args);
+  grpc_exec_ctx_flush();
+  grpc_pollset_destroy(args->pollset);
   gpr_free(args->pollset);
-  GRPC_COMBINER_UNREF(exec_ctx, args->lock, NULL);
+  GRPC_COMBINER_UNREF(args->lock, NULL);
 }
 
 gpr_timespec NSecondDeadline(int seconds) {
@@ -198,11 +198,11 @@ void PollPollsetUntilRequestDone(ArgsStruct* args) {
     ExecCtx _local_exec_ctx;
     gpr_mu_lock(args->mu);
     GRPC_LOG_IF_ERROR("pollset_work",
-                      grpc_pollset_work(&exec_ctx, args->pollset, &worker,
+                      grpc_pollset_work(args->pollset, &worker,
                                         grpc_timespec_to_millis_round_up(
                                             NSecondDeadline(1))));
     gpr_mu_unlock(args->mu);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_exec_ctx_finish();
   }
   gpr_event_set(&args->ev, (void*)1);
 }
@@ -234,8 +234,7 @@ void CheckLBPolicyResultLocked(grpc_channel_args* channel_args,
   }
 }
 
-void CheckResolverResultLocked(grpc_exec_ctx* exec_ctx, void* argsp,
-                               grpc_error* err) {
+void CheckResolverResultLocked(void* argsp, grpc_error* err) {
   ArgsStruct* args = (ArgsStruct*)argsp;
   grpc_channel_args* channel_args = args->channel_args;
   const grpc_arg* channel_arg =
@@ -271,15 +270,14 @@ void CheckResolverResultLocked(grpc_exec_ctx* exec_ctx, void* argsp,
   }
   gpr_atm_rel_store(&args->done_atm, 1);
   gpr_mu_lock(args->mu);
-  GRPC_LOG_IF_ERROR("pollset_kick",
-                    grpc_pollset_kick(exec_ctx, args->pollset, NULL));
+  GRPC_LOG_IF_ERROR("pollset_kick", grpc_pollset_kick(args->pollset, NULL));
   gpr_mu_unlock(args->mu);
 }
 
 TEST(ResolverComponentTest, TestResolvesRelevantRecords) {
   ExecCtx _local_exec_ctx;
   ArgsStruct args;
-  ArgsInit(&exec_ctx, &args);
+  ArgsInit(&args);
   args.expected_addrs = ParseExpectedAddrs(FLAGS_expected_addrs);
   args.expected_service_config_string = FLAGS_expected_chosen_service_config;
   args.expected_lb_policy = FLAGS_expected_lb_policy;
@@ -289,19 +287,19 @@ TEST(ResolverComponentTest, TestResolvesRelevantRecords) {
                       FLAGS_local_dns_server_address.c_str(),
                       FLAGS_target_name.c_str()));
   // create resolver and resolve
-  grpc_resolver* resolver = grpc_resolver_create(&exec_ctx, whole_uri, NULL,
-                                                 args.pollset_set, args.lock);
+  grpc_resolver* resolver =
+      grpc_resolver_create(whole_uri, NULL, args.pollset_set, args.lock);
   gpr_free(whole_uri);
   grpc_closure on_resolver_result_changed;
   GRPC_CLOSURE_INIT(&on_resolver_result_changed, CheckResolverResultLocked,
                     (void*)&args, grpc_combiner_scheduler(args.lock));
-  grpc_resolver_next_locked(&exec_ctx, resolver, &args.channel_args,
+  grpc_resolver_next_locked(resolver, &args.channel_args,
                             &on_resolver_result_changed);
-  grpc_exec_ctx_flush(&exec_ctx);
+  grpc_exec_ctx_flush();
   PollPollsetUntilRequestDone(&args);
-  GRPC_RESOLVER_UNREF(&exec_ctx, resolver, NULL);
-  ArgsFinish(&exec_ctx, &args);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_RESOLVER_UNREF(resolver, NULL);
+  ArgsFinish(&args);
+  grpc_exec_ctx_finish();
 }
 
 }  // namespace
diff --git a/test/cpp/performance/writes_per_rpc_test.cc b/test/cpp/performance/writes_per_rpc_test.cc
index 0e5233403e3..b05da25e1d5 100644
--- a/test/cpp/performance/writes_per_rpc_test.cc
+++ b/test/cpp/performance/writes_per_rpc_test.cc
@@ -89,19 +89,19 @@ class EndpointPairFixture {
       const grpc_channel_args* server_args =
           grpc_server_get_channel_args(server_->c_server());
       grpc_transport* transport = grpc_create_chttp2_transport(
-          &exec_ctx, server_args, endpoints.server, 0 /* is_client */);
+          server_args, endpoints.server, 0 /* is_client */);
 
       grpc_pollset** pollsets;
       size_t num_pollsets = 0;
       grpc_server_get_pollsets(server_->c_server(), &pollsets, &num_pollsets);
 
       for (size_t i = 0; i < num_pollsets; i++) {
-        grpc_endpoint_add_to_pollset(&exec_ctx, endpoints.server, pollsets[i]);
+        grpc_endpoint_add_to_pollset(endpoints.server, pollsets[i]);
       }
 
-      grpc_server_setup_transport(&exec_ctx, server_->c_server(), transport,
-                                  NULL, server_args);
-      grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+      grpc_server_setup_transport(server_->c_server(), transport, NULL,
+                                  server_args);
+      grpc_chttp2_transport_start_reading(transport, NULL);
     }
 
     /* create channel */
@@ -112,16 +112,16 @@ class EndpointPairFixture {
 
       grpc_channel_args c_args = args.c_channel_args();
       grpc_transport* transport =
-          grpc_create_chttp2_transport(&exec_ctx, &c_args, endpoints.client, 1);
+          grpc_create_chttp2_transport(&c_args, endpoints.client, 1);
       GPR_ASSERT(transport);
       grpc_channel* channel = grpc_channel_create(
-          &exec_ctx, "target", &c_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);
-      grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL);
+          "target", &c_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);
+      grpc_chttp2_transport_start_reading(transport, NULL);
 
       channel_ = CreateChannelInternal("", channel);
     }
 
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_exec_ctx_finish();
   }
 
   virtual ~EndpointPairFixture() {