Merge branch 'thread_pool' into ALL-the-things

24 files changed, 390 insertions, 379 deletions

diff --git a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
index 8e15faa1dd..3f5a2c946e 100644
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
@@ -126,11 +126,10 @@ static void call_resolver_next_after_locking(grpc_exec_ctx *exec_ctx,
   a->resolver = resolver;
   a->result = result;
   a->on_complete = on_complete;
-  grpc_closure_sched(
-      exec_ctx,
-      grpc_closure_create(call_resolver_next_now_lock_taken, a,
-                          grpc_combiner_scheduler(resolver->combiner, false)),
-      GRPC_ERROR_NONE);
+  grpc_closure_sched(exec_ctx, grpc_closure_create(
+                                   call_resolver_next_now_lock_taken, a,
+                                   grpc_combiner_scheduler(resolver->combiner)),
+                     GRPC_ERROR_NONE);
 }
 
 int main(int argc, char **argv) {
@@ -138,7 +137,7 @@ int main(int argc, char **argv) {
 
   grpc_init();
   gpr_mu_init(&g_mu);
-  g_combiner = grpc_combiner_create(NULL);
+  g_combiner = grpc_combiner_create();
   grpc_resolve_address = my_resolve_address;
   grpc_channel_args *result = (grpc_channel_args *)1;
 
diff --git a/test/core/client_channel/resolvers/dns_resolver_test.c b/test/core/client_channel/resolvers/dns_resolver_test.c
index fa7857d418..55bcc1a0d7 100644
--- a/test/core/client_channel/resolvers/dns_resolver_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_test.c
@@ -81,7 +81,7 @@ int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
-  g_combiner = grpc_combiner_create(NULL);
+  g_combiner = grpc_combiner_create();
 
   dns = grpc_resolver_factory_lookup("dns");
 
diff --git a/test/core/client_channel/resolvers/fake_resolver_test.c b/test/core/client_channel/resolvers/fake_resolver_test.c
index 861918fbd6..934fb1b074 100644
--- a/test/core/client_channel/resolvers/fake_resolver_test.c
+++ b/test/core/client_channel/resolvers/fake_resolver_test.c
@@ -67,12 +67,11 @@ static grpc_resolver *build_fake_resolver(
 typedef struct on_resolution_arg {
   grpc_channel_args *resolver_result;
   grpc_channel_args *expected_resolver_result;
-  bool was_called;
+  gpr_event ev;
 } on_resolution_arg;
 
 void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   on_resolution_arg *res = arg;
-  res->was_called = true;
   // We only check the addresses channel arg because that's the only one
   // explicitly set by the test via
   // grpc_fake_resolver_response_generator_set_response.
@@ -84,11 +83,12 @@ void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
       grpc_lb_addresses_cmp(actual_lb_addresses, expected_lb_addresses) == 0);
   grpc_channel_args_destroy(exec_ctx, res->resolver_result);
   grpc_channel_args_destroy(exec_ctx, res->expected_resolver_result);
+  gpr_event_set(&res->ev, (void *)1);
 }
 
 static void test_fake_resolver() {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_combiner *combiner = grpc_combiner_create(NULL);
+  grpc_combiner *combiner = grpc_combiner_create();
   // Create resolver.
   grpc_fake_resolver_response_generator *response_generator =
       grpc_fake_resolver_response_generator_create();
@@ -115,8 +115,9 @@ static void test_fake_resolver() {
   on_resolution_arg on_res_arg;
   memset(&on_res_arg, 0, sizeof(on_res_arg));
   on_res_arg.expected_resolver_result = results;
+  gpr_event_init(&on_res_arg.ev);
   grpc_closure *on_resolution = grpc_closure_create(
-      on_resolution_cb, &on_res_arg, grpc_combiner_scheduler(combiner, false));
+      on_resolution_cb, &on_res_arg, grpc_combiner_scheduler(combiner));
 
   // Set resolver results and trigger first resolution. on_resolution_cb
   // performs the checks.
@@ -125,7 +126,8 @@ static void test_fake_resolver() {
   grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
                             on_resolution);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(on_res_arg.was_called);
+  GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 
   // Setup update.
   grpc_uri *uris_update[] = {
@@ -150,8 +152,9 @@ static void test_fake_resolver() {
   on_resolution_arg on_res_arg_update;
   memset(&on_res_arg_update, 0, sizeof(on_res_arg_update));
   on_res_arg_update.expected_resolver_result = results_update;
+  gpr_event_init(&on_res_arg_update.ev);
   on_resolution = grpc_closure_create(on_resolution_cb, &on_res_arg_update,
-                                      grpc_combiner_scheduler(combiner, false));
+                                      grpc_combiner_scheduler(combiner));
 
   // Set updated resolver results and trigger a second resolution.
   grpc_fake_resolver_response_generator_set_response(
@@ -159,7 +162,8 @@ static void test_fake_resolver() {
   grpc_resolver_next_locked(&exec_ctx, resolver,
                             &on_res_arg_update.resolver_result, on_resolution);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(on_res_arg.was_called);
+  GPR_ASSERT(gpr_event_wait(&on_res_arg_update.ev,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 
   // Requesting a new resolution without re-senting the response shouldn't
   // trigger the resolution callback.
@@ -167,7 +171,9 @@ static void test_fake_resolver() {
   grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
                             on_resolution);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(!on_res_arg.was_called);
+  GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
+                            grpc_timeout_milliseconds_to_deadline(100)) ==
+             NULL);
 
   GRPC_COMBINER_UNREF(&exec_ctx, combiner, "test_fake_resolver");
   GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test_fake_resolver");
diff --git a/test/core/client_channel/resolvers/sockaddr_resolver_test.c b/test/core/client_channel/resolvers/sockaddr_resolver_test.c
index 847eabae3b..5049946852 100644
--- a/test/core/client_channel/resolvers/sockaddr_resolver_test.c
+++ b/test/core/client_channel/resolvers/sockaddr_resolver_test.c
@@ -104,7 +104,7 @@ int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
-  g_combiner = grpc_combiner_create(NULL);
+  g_combiner = grpc_combiner_create();
 
   ipv4 = grpc_resolver_factory_lookup("ipv4");
   ipv6 = grpc_resolver_factory_lookup("ipv6");
diff --git a/test/core/end2end/fake_resolver.c b/test/core/end2end/fake_resolver.c
index 736b224fd6..c84e53e26c 100644
--- a/test/core/end2end/fake_resolver.c
+++ b/test/core/end2end/fake_resolver.c
@@ -173,10 +173,9 @@ void grpc_fake_resolver_response_generator_set_response(
   GPR_ASSERT(generator->resolver != NULL);
   generator->next_response = grpc_channel_args_copy(next_response);
   grpc_closure_sched(
-      exec_ctx,
-      grpc_closure_create(
-          set_response_cb, generator,
-          grpc_combiner_scheduler(generator->resolver->base.combiner, false)),
+      exec_ctx, grpc_closure_create(set_response_cb, generator,
+                                    grpc_combiner_scheduler(
+                                        generator->resolver->base.combiner)),
       GRPC_ERROR_NONE);
 }
 
diff --git a/test/core/end2end/fixtures/http_proxy_fixture.c b/test/core/end2end/fixtures/http_proxy_fixture.c
index b8a53ed113..c8e9559173 100644
--- a/test/core/end2end/fixtures/http_proxy_fixture.c
+++ b/test/core/end2end/fixtures/http_proxy_fixture.c
@@ -403,19 +403,19 @@ static void on_accept(grpc_exec_ctx* exec_ctx, void* arg,
   grpc_pollset_set_add_pollset(exec_ctx, conn->pollset_set, proxy->pollset);
   grpc_endpoint_add_to_pollset_set(exec_ctx, endpoint, conn->pollset_set);
   grpc_closure_init(&conn->on_read_request_done, on_read_request_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_server_connect_done, on_server_connect_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_write_response_done, on_write_response_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_client_read_done, on_client_read_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_client_write_done, on_client_write_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_server_read_done, on_server_read_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_server_write_done, on_server_write_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_slice_buffer_init(&conn->client_read_buffer);
   grpc_slice_buffer_init(&conn->client_deferred_write_buffer);
   grpc_slice_buffer_init(&conn->client_write_buffer);
@@ -456,7 +456,7 @@ grpc_end2end_http_proxy* grpc_end2end_http_proxy_create(void) {
   grpc_end2end_http_proxy* proxy =
       (grpc_end2end_http_proxy*)gpr_malloc(sizeof(*proxy));
   memset(proxy, 0, sizeof(*proxy));
-  proxy->combiner = grpc_combiner_create(NULL);
+  proxy->combiner = grpc_combiner_create();
   gpr_ref_init(&proxy->users, 1);
   // Construct proxy address.
   const int proxy_port = grpc_pick_unused_port_or_die();
diff --git a/test/core/end2end/fuzzers/api_fuzzer.c b/test/core/end2end/fuzzers/api_fuzzer.c
index b33b43dac5..d8d34fba9c 100644
--- a/test/core/end2end/fuzzers/api_fuzzer.c
+++ b/test/core/end2end/fuzzers/api_fuzzer.c
@@ -41,6 +41,7 @@
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/timer.h"
@@ -724,6 +725,11 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   gpr_now_impl = now_impl;
   grpc_init();
   grpc_timer_manager_set_threading(false);
+  {
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_executor_set_threading(&exec_ctx, false);
+    grpc_exec_ctx_finish(&exec_ctx);
+  }
   grpc_resolve_address = my_resolve_address;
 
   GPR_ASSERT(g_channel == NULL);
diff --git a/test/core/end2end/fuzzers/client_fuzzer.c b/test/core/end2end/fuzzers/client_fuzzer.c
index 6f49baffd2..2307a3c771 100644
--- a/test/core/end2end/fuzzers/client_fuzzer.c
+++ b/test/core/end2end/fuzzers/client_fuzzer.c
@@ -37,6 +37,7 @@
 #include <grpc/support/alloc.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/channel.h"
 #include "test/core/util/memory_counters.h"
@@ -58,6 +59,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   if (leak_check) grpc_memory_counters_init();
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_executor_set_threading(&exec_ctx, false);
 
   grpc_resource_quota *resource_quota =
       grpc_resource_quota_create("client_fuzzer");
diff --git a/test/core/end2end/fuzzers/server_fuzzer.c b/test/core/end2end/fuzzers/server_fuzzer.c
index 6d65fe1847..e6f6be2325 100644
--- a/test/core/end2end/fuzzers/server_fuzzer.c
+++ b/test/core/end2end/fuzzers/server_fuzzer.c
@@ -34,6 +34,7 @@
 #include <grpc/grpc.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/server.h"
 #include "test/core/util/memory_counters.h"
@@ -56,6 +57,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   if (leak_check) grpc_memory_counters_init();
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_executor_set_threading(&exec_ctx, false);
 
   grpc_resource_quota *resource_quota =
       grpc_resource_quota_create("server_fuzzer");
diff --git a/test/core/iomgr/combiner_test.c b/test/core/iomgr/combiner_test.c
index bc4d2af8ac..beb5c47623 100644
--- a/test/core/iomgr/combiner_test.c
+++ b/test/core/iomgr/combiner_test.c
@@ -44,27 +44,29 @@
 static void test_no_op(void) {
   gpr_log(GPR_DEBUG, "test_no_op");
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GRPC_COMBINER_UNREF(&exec_ctx, grpc_combiner_create(NULL), "test_no_op");
+  GRPC_COMBINER_UNREF(&exec_ctx, grpc_combiner_create(), "test_no_op");
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void set_bool_to_true(grpc_exec_ctx *exec_ctx, void *value,
-                             grpc_error *error) {
-  *(bool *)value = true;
+static void set_event_to_true(grpc_exec_ctx *exec_ctx, void *value,
+                              grpc_error *error) {
+  gpr_event_set(value, (void *)1);
 }
 
 static void test_execute_one(void) {
   gpr_log(GPR_DEBUG, "test_execute_one");
 
-  grpc_combiner *lock = grpc_combiner_create(NULL);
-  bool done = false;
+  grpc_combiner *lock = grpc_combiner_create();
+  gpr_event done;
+  gpr_event_init(&done);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_closure_sched(&exec_ctx,
-                     grpc_closure_create(set_bool_to_true, &done,
-                                         grpc_combiner_scheduler(lock, false)),
+                     grpc_closure_create(set_event_to_true, &done,
+                                         grpc_combiner_scheduler(lock)),
                      GRPC_ERROR_NONE);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(done);
+  GPR_ASSERT(gpr_event_wait(&done, grpc_timeout_seconds_to_deadline(5)) !=
+             NULL);
   GRPC_COMBINER_UNREF(&exec_ctx, lock, "test_execute_one");
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -72,6 +74,7 @@ static void test_execute_one(void) {
 typedef struct {
   size_t ctr;
   grpc_combiner *lock;
+  gpr_event done;
 } thd_args;
 
 typedef struct {
@@ -95,23 +98,27 @@ static void execute_many_loop(void *a) {
       ex_args *c = gpr_malloc(sizeof(*c));
       c->ctr = &args->ctr;
       c->value = n++;
-      grpc_closure_sched(
-          &exec_ctx, grpc_closure_create(check_one, c, grpc_combiner_scheduler(
-                                                           args->lock, false)),
-          GRPC_ERROR_NONE);
+      grpc_closure_sched(&exec_ctx,
+                         grpc_closure_create(
+                             check_one, c, grpc_combiner_scheduler(args->lock)),
+                         GRPC_ERROR_NONE);
       grpc_exec_ctx_flush(&exec_ctx);
     }
     // sleep for a little bit, to test a combiner draining and another thread
     // picking it up
     gpr_sleep_until(grpc_timeout_milliseconds_to_deadline(100));
   }
+  grpc_closure_sched(&exec_ctx,
+                     grpc_closure_create(set_event_to_true, &args->done,
+                                         grpc_combiner_scheduler(args->lock)),
+                     GRPC_ERROR_NONE);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_execute_many(void) {
   gpr_log(GPR_DEBUG, "test_execute_many");
 
-  grpc_combiner *lock = grpc_combiner_create(NULL);
+  grpc_combiner *lock = grpc_combiner_create();
   gpr_thd_id thds[100];
   thd_args ta[GPR_ARRAY_SIZE(thds)];
   for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
@@ -119,9 +126,12 @@ static void test_execute_many(void) {
     gpr_thd_options_set_joinable(&options);
     ta[i].ctr = 0;
     ta[i].lock = lock;
+    gpr_event_init(&ta[i].done);
     GPR_ASSERT(gpr_thd_new(&thds[i], execute_many_loop, &ta[i], &options));
   }
   for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
+    GPR_ASSERT(gpr_event_wait(&ta[i].done,
+                              gpr_inf_future(GPR_CLOCK_REALTIME)) != NULL);
     gpr_thd_join(thds[i]);
   }
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -129,30 +139,32 @@ static void test_execute_many(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static bool got_in_finally = false;
+static gpr_event got_in_finally;
 
 static void in_finally(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  got_in_finally = true;
+  gpr_event_set(&got_in_finally, (void *)1);
 }
 
 static void add_finally(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_closure_sched(exec_ctx, grpc_closure_create(
-                                   in_finally, NULL,
-                                   grpc_combiner_finally_scheduler(arg, false)),
+  grpc_closure_sched(exec_ctx,
+                     grpc_closure_create(in_finally, arg,
+                                         grpc_combiner_finally_scheduler(arg)),
                      GRPC_ERROR_NONE);
 }
 
 static void test_execute_finally(void) {
   gpr_log(GPR_DEBUG, "test_execute_finally");
 
-  grpc_combiner *lock = grpc_combiner_create(NULL);
+  grpc_combiner *lock = grpc_combiner_create();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_closure_sched(&exec_ctx,
-                     grpc_closure_create(add_finally, lock,
-                                         grpc_combiner_scheduler(lock, false)),
-                     GRPC_ERROR_NONE);
+  gpr_event_init(&got_in_finally);
+  grpc_closure_sched(
+      &exec_ctx,
+      grpc_closure_create(add_finally, lock, grpc_combiner_scheduler(lock)),
+      GRPC_ERROR_NONE);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(got_in_finally);
+  GPR_ASSERT(gpr_event_wait(&got_in_finally,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
   GRPC_COMBINER_UNREF(&exec_ctx, lock, "test_execute_finally");
   grpc_exec_ctx_finish(&exec_ctx);
 }
diff --git a/test/core/iomgr/endpoint_tests.c b/test/core/iomgr/endpoint_tests.c
index e274796e23..6f86d40a29 100644
--- a/test/core/iomgr/endpoint_tests.c
+++ b/test/core/iomgr/endpoint_tests.c
@@ -265,25 +265,30 @@ static void read_and_write_test(grpc_endpoint_test_config config,
 
 static void inc_on_failure(grpc_exec_ctx *exec_ctx, void *arg,
                            grpc_error *error) {
+  gpr_mu_lock(g_mu);
   *(int *)arg += (error != GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(g_pollset, NULL)));
+  gpr_mu_unlock(g_mu);
 }
 
 static void wait_for_fail_count(grpc_exec_ctx *exec_ctx, int *fail_count,
                                 int want_fail_count) {
   grpc_exec_ctx_flush(exec_ctx);
-  for (int i = 0; i < 5 && *fail_count < want_fail_count; i++) {
+  gpr_mu_lock(g_mu);
+  gpr_timespec deadline = grpc_timeout_seconds_to_deadline(10);
+  while (gpr_time_cmp(gpr_now(deadline.clock_type), deadline) < 0 &&
+         *fail_count < want_fail_count) {
     grpc_pollset_worker *worker = NULL;
-    gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
-    gpr_timespec deadline =
-        gpr_time_add(now, gpr_time_from_seconds(1, GPR_TIMESPAN));
-    gpr_mu_lock(g_mu);
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
-        grpc_pollset_work(exec_ctx, g_pollset, &worker, now, deadline)));
+        grpc_pollset_work(exec_ctx, g_pollset, &worker,
+                          gpr_now(deadline.clock_type), deadline)));
     gpr_mu_unlock(g_mu);
     grpc_exec_ctx_flush(exec_ctx);
+    gpr_mu_lock(g_mu);
   }
   GPR_ASSERT(*fail_count == want_fail_count);
+  gpr_mu_unlock(g_mu);
 }
 
 static void multiple_shutdown_test(grpc_endpoint_test_config config) {
diff --git a/test/core/iomgr/ev_epollsig_linux_test.c b/test/core/iomgr/ev_epollsig_linux_test.c
index 45c542de4e..952e774670 100644
--- a/test/core/iomgr/ev_epollsig_linux_test.c
+++ b/test/core/iomgr/ev_epollsig_linux_test.c
@@ -47,7 +47,6 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/iomgr/workqueue.h"
 #include "test/core/util/test_config.h"
 
 typedef struct test_pollset {
@@ -131,86 +130,6 @@ static void test_pollset_cleanup(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void increment(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  ++*(int *)arg;
-}
-
-/*
- * Validate that merging two workqueues preserves the closures in each queue.
- * This is a regression test for a bug in
- * polling_island_merge()[ev_epoll_linux.c], where the parent relationship was
- * inverted.
- */
-
-#define NUM_FDS 2
-#define NUM_POLLSETS 2
-#define NUM_CLOSURES 4
-
-static void test_pollset_queue_merge_items() {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  test_fd tfds[NUM_FDS];
-  int fds[NUM_FDS];
-  test_pollset pollsets[NUM_POLLSETS];
-  grpc_closure closures[NUM_CLOSURES];
-  int i;
-  int result = 0;
-
-  test_fd_init(tfds, fds, NUM_FDS);
-  test_pollset_init(pollsets, NUM_POLLSETS);
-
-  /* Two distinct polling islands, each with their own FD and pollset. */
-  for (i = 0; i < NUM_FDS; i++) {
-    grpc_pollset_add_fd(&exec_ctx, pollsets[i].pollset, tfds[i].fd);
-    grpc_exec_ctx_flush(&exec_ctx);
-  }
-
-  /* Enqeue the closures, 3 to polling island 0 and 1 to polling island 1. */
-  grpc_closure_init(
-      closures, increment, &result,
-      grpc_workqueue_scheduler(grpc_fd_get_polling_island(tfds[0].fd)));
-  grpc_closure_init(
-      closures + 1, increment, &result,
-      grpc_workqueue_scheduler(grpc_fd_get_polling_island(tfds[0].fd)));
-  grpc_closure_init(
-      closures + 2, increment, &result,
-      grpc_workqueue_scheduler(grpc_fd_get_polling_island(tfds[0].fd)));
-  grpc_closure_init(
-      closures + 3, increment, &result,
-      grpc_workqueue_scheduler(grpc_fd_get_polling_island(tfds[1].fd)));
-  for (i = 0; i < NUM_CLOSURES; ++i) {
-    grpc_closure_sched(&exec_ctx, closures + i, GRPC_ERROR_NONE);
-  }
-
-  /* Merge the two polling islands. */
-  grpc_pollset_add_fd(&exec_ctx, pollsets[0].pollset, tfds[1].fd);
-  grpc_exec_ctx_flush(&exec_ctx);
-
-  /*
-   * Execute the closures, verify we see each one execute when executing work on
-   * the merged polling island.
-   */
-  grpc_pollset_worker *worker = NULL;
-  for (i = 0; i < NUM_CLOSURES; ++i) {
-    const gpr_timespec deadline = gpr_time_add(
-        gpr_now(GPR_CLOCK_MONOTONIC), gpr_time_from_seconds(2, GPR_TIMESPAN));
-    gpr_mu_lock(pollsets[1].mu);
-    GRPC_LOG_IF_ERROR(
-        "grpc_pollset_work",
-        grpc_pollset_work(&exec_ctx, pollsets[1].pollset, &worker,
-                          gpr_now(GPR_CLOCK_MONOTONIC), deadline));
-    gpr_mu_unlock(pollsets[1].mu);
-  }
-  GPR_ASSERT(result == NUM_CLOSURES);
-
-  test_fd_cleanup(&exec_ctx, tfds, NUM_FDS);
-  test_pollset_cleanup(&exec_ctx, pollsets, NUM_POLLSETS);
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-#undef NUM_FDS
-#undef NUM_POLLSETS
-#undef NUM_CLOSURES
-
 /*
  * Cases to test:
  *  case 1) Polling islands of both fd and pollset are NULL
@@ -402,13 +321,13 @@ static void test_threading(void) {
 int main(int argc, char **argv) {
   const char *poll_strategy = NULL;
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
 
   poll_strategy = grpc_get_poll_strategy_name();
   if (poll_strategy != NULL && strcmp(poll_strategy, "epollsig") == 0) {
     test_add_fd_to_pollset();
-    test_pollset_queue_merge_items();
     test_threading();
   } else {
     gpr_log(GPR_INFO,
@@ -417,11 +336,8 @@ int main(int argc, char **argv) {
             poll_strategy);
   }
 
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_iomgr_shutdown(&exec_ctx);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_iomgr_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return 0;
 }
 #else /* defined(GRPC_LINUX_EPOLL) */
diff --git a/test/core/iomgr/fd_conservation_posix_test.c b/test/core/iomgr/fd_conservation_posix_test.c
index f662070655..18d8cf4ec8 100644
--- a/test/core/iomgr/fd_conservation_posix_test.c
+++ b/test/core/iomgr/fd_conservation_posix_test.c
@@ -45,8 +45,9 @@ int main(int argc, char **argv) {
   grpc_endpoint_pair p;
 
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
 
   /* set max # of file descriptors to a low value, and
      verify we can create and destroy many more than this number
@@ -57,19 +58,15 @@ int main(int argc, char **argv) {
       grpc_resource_quota_create("fd_conservation_posix_test");
 
   for (i = 0; i < 100; i++) {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     p = grpc_iomgr_create_endpoint_pair("test", NULL);
     grpc_endpoint_destroy(&exec_ctx, p.client);
     grpc_endpoint_destroy(&exec_ctx, p.server);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_exec_ctx_flush(&exec_ctx);
   }
 
   grpc_resource_quota_unref(resource_quota);
 
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_iomgr_shutdown(&exec_ctx);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_iomgr_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return 0;
 }
diff --git a/test/core/iomgr/fd_posix_test.c b/test/core/iomgr/fd_posix_test.c
index 9e8fe8bffa..d0f31e087d 100644
--- a/test/core/iomgr/fd_posix_test.c
+++ b/test/core/iomgr/fd_posix_test.c
@@ -542,8 +542,8 @@ int main(int argc, char **argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
   g_pollset = gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(g_pollset, &g_mu);
   test_grpc_fd();
diff --git a/test/core/iomgr/pollset_set_test.c b/test/core/iomgr/pollset_set_test.c
index 092711381d..587130704d 100644
--- a/test/core/iomgr/pollset_set_test.c
+++ b/test/core/iomgr/pollset_set_test.c
@@ -447,8 +447,8 @@ int main(int argc, char **argv) {
   const char *poll_strategy = grpc_get_poll_strategy_name();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
 
   if (poll_strategy != NULL &&
       (strcmp(poll_strategy, "epoll") == 0 ||
diff --git a/test/core/iomgr/resolve_address_posix_test.c b/test/core/iomgr/resolve_address_posix_test.c
index bee7036ec8..f07bd045b6 100644
--- a/test/core/iomgr/resolve_address_posix_test.c
+++ b/test/core/iomgr/resolve_address_posix_test.c
@@ -174,16 +174,13 @@ static void test_unix_socket_path_name_too_long(void) {
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
-  grpc_executor_init();
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
   test_unix_socket();
   test_unix_socket_path_name_too_long();
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_executor_shutdown(&exec_ctx);
-    grpc_iomgr_shutdown(&exec_ctx);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_executor_shutdown(&exec_ctx);
+  grpc_iomgr_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return 0;
 }
diff --git a/test/core/iomgr/resolve_address_test.c b/test/core/iomgr/resolve_address_test.c
index 83f73070dc..51706904d5 100644
--- a/test/core/iomgr/resolve_address_test.c
+++ b/test/core/iomgr/resolve_address_test.c
@@ -73,7 +73,9 @@ void args_finish(grpc_exec_ctx *exec_ctx, args_struct *args) {
   grpc_closure do_nothing_cb;
   grpc_closure_init(&do_nothing_cb, do_nothing, NULL,
                     grpc_schedule_on_exec_ctx);
+  gpr_mu_lock(args->mu);
   grpc_pollset_shutdown(exec_ctx, args->pollset, &do_nothing_cb);
+  gpr_mu_unlock(args->mu);
   // exec_ctx needs to be flushed before calling grpc_pollset_destroy()
   grpc_exec_ctx_flush(exec_ctx);
   grpc_pollset_destroy(exec_ctx, args->pollset);
@@ -263,9 +265,9 @@ static void test_unparseable_hostports(void) {
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
-  grpc_executor_init();
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
   test_localhost();
   test_default_port();
   test_non_numeric_default_port();
@@ -274,11 +276,8 @@ int main(int argc, char **argv) {
   test_ipv6_without_port();
   test_invalid_ip_addresses();
   test_unparseable_hostports();
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_executor_shutdown(&exec_ctx);
-    grpc_iomgr_shutdown(&exec_ctx);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_executor_shutdown(&exec_ctx);
+  grpc_iomgr_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return 0;
 }
diff --git a/test/core/iomgr/resource_quota_test.c b/test/core/iomgr/resource_quota_test.c
index ebce8b9da6..488086d6ab 100644
--- a/test/core/iomgr/resource_quota_test.c
+++ b/test/core/iomgr/resource_quota_test.c
@@ -39,15 +39,30 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "test/core/util/test_config.h"
 
+gpr_mu g_mu;
+gpr_cv g_cv;
+
 static void inc_int_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
+  gpr_mu_lock(&g_mu);
   ++*(int *)a;
+  gpr_cv_signal(&g_cv);
+  gpr_mu_unlock(&g_mu);
+}
+
+static void assert_counter_becomes(int *ctr, int value) {
+  gpr_mu_lock(&g_mu);
+  gpr_timespec deadline = grpc_timeout_seconds_to_deadline(5);
+  while (*ctr != value) {
+    GPR_ASSERT(!gpr_cv_wait(&g_cv, &g_mu, deadline));
+  }
+  gpr_mu_unlock(&g_mu);
 }
 
-static void set_bool_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
-  *(bool *)a = true;
+static void set_event_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
+  gpr_event_set((gpr_event *)a, (void *)1);
 }
-grpc_closure *set_bool(bool *p) {
-  return grpc_closure_create(set_bool_cb, p, grpc_schedule_on_exec_ctx);
+grpc_closure *set_event(gpr_event *ev) {
+  return grpc_closure_create(set_event_cb, ev, grpc_schedule_on_exec_ctx);
 }
 
 typedef struct {
@@ -154,11 +169,13 @@ static void test_simple_async_alloc(void) {
   grpc_resource_quota_resize(q, 1024 * 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -175,15 +192,18 @@ static void test_async_alloc_blocked_by_size(void) {
       grpc_resource_quota_create("test_async_alloc_blocked_by_size");
   grpc_resource_quota_resize(q, 1);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-  bool done = false;
+  gpr_event ev;
+  gpr_event_init(&ev);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!done);
+    GPR_ASSERT(gpr_event_wait(
+                   &ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
   }
   grpc_resource_quota_resize(q, 1024);
-  GPR_ASSERT(done);
+  GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) != NULL);
+  ;
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_free(&exec_ctx, usr, 1024);
@@ -200,11 +220,14 @@ static void test_scavenge(void) {
   grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
   grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -212,11 +235,14 @@ static void test_scavenge(void) {
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -234,26 +260,31 @@ static void test_scavenge_blocked(void) {
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
   grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
-  bool done;
+  gpr_event ev;
   {
-    done = false;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
-    done = false;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!done);
+    GPR_ASSERT(gpr_event_wait(
+                   &ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_free(&exec_ctx, usr1, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -272,27 +303,35 @@ static void test_blocked_until_scheduled_reclaim(void) {
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
-  bool reclaim_done = false;
+  gpr_event reclaim_done;
+  gpr_event_init(&reclaim_done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, false,
-        make_reclaimer(usr, 1024, set_bool(&reclaim_done)));
+        make_reclaimer(usr, 1024, set_event(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(reclaim_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&reclaim_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -311,27 +350,35 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
   grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
   grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
-  bool reclaim_done = false;
+  gpr_event reclaim_done;
+  gpr_event_init(&reclaim_done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr1, false,
-        make_reclaimer(usr1, 1024, set_bool(&reclaim_done)));
+        make_reclaimer(usr1, 1024, set_event(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(reclaim_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&reclaim_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -350,27 +397,35 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
-  bool reclaim_done = false;
+  gpr_event reclaim_done;
+  gpr_event_init(&reclaim_done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, true,
-        make_reclaimer(usr, 1024, set_bool(&reclaim_done)));
+        make_reclaimer(usr, 1024, set_event(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(reclaim_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&reclaim_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -387,23 +442,31 @@ static void test_unused_reclaim_is_cancelled(void) {
       grpc_resource_quota_create("test_unused_reclaim_is_cancelled");
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-  bool benign_done = false;
-  bool destructive_done = false;
+  gpr_event benign_done;
+  gpr_event_init(&benign_done);
+  gpr_event destructive_done;
+  gpr_event_init(&destructive_done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, usr, false, make_unused_reclaimer(set_bool(&benign_done)));
+        &exec_ctx, usr, false, make_unused_reclaimer(set_event(&benign_done)));
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, true,
-        make_unused_reclaimer(set_bool(&destructive_done)));
+        make_unused_reclaimer(set_event(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!benign_done);
-    GPR_ASSERT(!destructive_done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
   }
   grpc_resource_quota_unref(q);
   destroy_user(usr);
-  GPR_ASSERT(benign_done);
-  GPR_ASSERT(destructive_done);
+  GPR_ASSERT(gpr_event_wait(&benign_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+  GPR_ASSERT(gpr_event_wait(&destructive_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 }
 
 static void test_benign_reclaim_is_preferred(void) {
@@ -412,35 +475,49 @@ static void test_benign_reclaim_is_preferred(void) {
       grpc_resource_quota_create("test_benign_reclaim_is_preferred");
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-  bool benign_done = false;
-  bool destructive_done = false;
+  gpr_event benign_done;
+  gpr_event_init(&benign_done);
+  gpr_event destructive_done;
+  gpr_event_init(&destructive_done);
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, false,
-        make_reclaimer(usr, 1024, set_bool(&benign_done)));
+        make_reclaimer(usr, 1024, set_event(&benign_done)));
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, true,
-        make_unused_reclaimer(set_bool(&destructive_done)));
+        make_unused_reclaimer(set_event(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!benign_done);
-    GPR_ASSERT(!destructive_done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(benign_done);
-    GPR_ASSERT(!destructive_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -449,8 +526,10 @@ static void test_benign_reclaim_is_preferred(void) {
   }
   grpc_resource_quota_unref(q);
   destroy_user(usr);
-  GPR_ASSERT(benign_done);
-  GPR_ASSERT(destructive_done);
+  GPR_ASSERT(gpr_event_wait(&benign_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+  GPR_ASSERT(gpr_event_wait(&destructive_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 }
 
 static void test_multiple_reclaims_can_be_triggered(void) {
@@ -459,35 +538,49 @@ static void test_multiple_reclaims_can_be_triggered(void) {
       grpc_resource_quota_create("test_multiple_reclaims_can_be_triggered");
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-  bool benign_done = false;
-  bool destructive_done = false;
+  gpr_event benign_done;
+  gpr_event_init(&benign_done);
+  gpr_event destructive_done;
+  gpr_event_init(&destructive_done);
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, false,
-        make_reclaimer(usr, 512, set_bool(&benign_done)));
+        make_reclaimer(usr, 512, set_event(&benign_done)));
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, true,
-        make_reclaimer(usr, 512, set_bool(&destructive_done)));
+        make_reclaimer(usr, 512, set_event(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!benign_done);
-    GPR_ASSERT(!destructive_done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(benign_done);
-    GPR_ASSERT(destructive_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -496,8 +589,10 @@ static void test_multiple_reclaims_can_be_triggered(void) {
   }
   grpc_resource_quota_unref(q);
   destroy_user(usr);
-  GPR_ASSERT(benign_done);
-  GPR_ASSERT(destructive_done);
+  GPR_ASSERT(gpr_event_wait(&benign_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+  GPR_ASSERT(gpr_event_wait(&destructive_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 }
 
 static void test_resource_user_stays_allocated_until_memory_released(void) {
@@ -538,34 +633,44 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
   grpc_resource_quota_resize(q, 1024);
   for (int i = 0; i < 10; i++) {
     grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-    bool reclaimer_cancelled = false;
+    gpr_event reclaimer_cancelled;
+    gpr_event_init(&reclaimer_cancelled);
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_post_reclaimer(
           &exec_ctx, usr, false,
-          make_unused_reclaimer(set_bool(&reclaimer_cancelled)));
+          make_unused_reclaimer(set_event(&reclaimer_cancelled)));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(!reclaimer_cancelled);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
+                                grpc_timeout_milliseconds_to_deadline(100)) ==
+                 NULL);
     }
     {
-      bool allocated = false;
+      gpr_event allocated;
+      gpr_event_init(&allocated);
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
+      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(allocated);
-      GPR_ASSERT(!reclaimer_cancelled);
+      GPR_ASSERT(gpr_event_wait(&allocated,
+                                grpc_timeout_seconds_to_deadline(5)) != NULL);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
+                                grpc_timeout_milliseconds_to_deadline(100)) ==
+                 NULL);
     }
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_unref(&exec_ctx, usr);
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(!reclaimer_cancelled);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
+                                grpc_timeout_milliseconds_to_deadline(100)) ==
+                 NULL);
     }
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_free(&exec_ctx, usr, 1024);
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(reclaimer_cancelled);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
+                                grpc_timeout_seconds_to_deadline(5)) != NULL);
     }
   }
   grpc_resource_quota_unref(q);
@@ -578,29 +683,37 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
-    bool allocated = false;
+    gpr_event allocated;
+    gpr_event_init(&allocated);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(allocated);
+    GPR_ASSERT(gpr_event_wait(&allocated,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
   }
   for (int i = 0; i < 10; i++) {
-    bool reclaimer_done = false;
+    gpr_event reclaimer_done;
+    gpr_event_init(&reclaimer_done);
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_post_reclaimer(
           &exec_ctx, usr, false,
-          make_reclaimer(usr, 1024, set_bool(&reclaimer_done)));
+          make_reclaimer(usr, 1024, set_event(&reclaimer_done)));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(!reclaimer_done);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_done,
+                                grpc_timeout_milliseconds_to_deadline(100)) ==
+                 NULL);
     }
     {
-      bool allocated = false;
+      gpr_event allocated;
+      gpr_event_init(&allocated);
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
+      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(allocated);
-      GPR_ASSERT(reclaimer_done);
+      GPR_ASSERT(gpr_event_wait(&allocated,
+                                grpc_timeout_seconds_to_deadline(5)) != NULL);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_done,
+                                grpc_timeout_seconds_to_deadline(5)) != NULL);
     }
   }
   {
@@ -632,7 +745,7 @@ static void test_one_slice(void) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_alloc_slices(&exec_ctx, &alloc, 1024, 1, &buffer);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(num_allocs == start_allocs + 1);
+    assert_counter_becomes(&num_allocs, start_allocs + 1);
   }
 
   {
@@ -665,7 +778,7 @@ static void test_one_slice_deleted_late(void) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_alloc_slices(&exec_ctx, &alloc, 1024, 1, &buffer);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(num_allocs == start_allocs + 1);
+    assert_counter_becomes(&num_allocs, start_allocs + 1);
   }
 
   {
@@ -709,7 +822,7 @@ static void test_negative_rq_free_pool(void) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_alloc_slices(&exec_ctx, &alloc, 1024, 1, &buffer);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(num_allocs == start_allocs + 1);
+    assert_counter_becomes(&num_allocs, start_allocs + 1);
   }
 
   grpc_resource_quota_resize(q, 512);
@@ -735,6 +848,8 @@ static void test_negative_rq_free_pool(void) {
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
+  gpr_mu_init(&g_mu);
+  gpr_cv_init(&g_cv);
   test_no_op();
   test_resize_then_destroy();
   test_resource_user_no_op();
@@ -757,6 +872,8 @@ int main(int argc, char **argv) {
   test_one_slice_deleted_late();
   test_resize_to_zero();
   test_negative_rq_free_pool();
+  gpr_mu_destroy(&g_mu);
+  gpr_cv_destroy(&g_cv);
   grpc_shutdown();
   return 0;
 }
diff --git a/test/core/iomgr/tcp_posix_test.c b/test/core/iomgr/tcp_posix_test.c
index a1c54e19c1..13131d1a52 100644
--- a/test/core/iomgr/tcp_posix_test.c
+++ b/test/core/iomgr/tcp_posix_test.c
@@ -162,6 +162,7 @@ static void read_cb(grpc_exec_ctx *exec_ctx, void *user_data,
   gpr_log(GPR_INFO, "Read %" PRIuPTR " bytes of %" PRIuPTR, read_bytes,
           state->target_read_bytes);
   if (state->read_bytes >= state->target_read_bytes) {
+    GPR_ASSERT(GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(g_pollset, NULL)));
     gpr_mu_unlock(g_mu);
   } else {
     grpc_endpoint_read(exec_ctx, state->ep, &state->incoming, &state->read_cb);
diff --git a/test/core/util/mock_endpoint.c b/test/core/util/mock_endpoint.c
index c747297984..e65c88b0bf 100644
--- a/test/core/util/mock_endpoint.c
+++ b/test/core/util/mock_endpoint.c
@@ -117,18 +117,9 @@ static grpc_resource_user *me_get_resource_user(grpc_endpoint *ep) {
 
 static int me_get_fd(grpc_endpoint *ep) { return -1; }
 
-static grpc_workqueue *me_get_workqueue(grpc_endpoint *ep) { return NULL; }
-
 static const grpc_endpoint_vtable vtable = {
-    me_read,
-    me_write,
-    me_get_workqueue,
-    me_add_to_pollset,
-    me_add_to_pollset_set,
-    me_shutdown,
-    me_destroy,
-    me_get_resource_user,
-    me_get_peer,
+    me_read,     me_write,   me_add_to_pollset,    me_add_to_pollset_set,
+    me_shutdown, me_destroy, me_get_resource_user, me_get_peer,
     me_get_fd,
 };
 
diff --git a/test/core/util/passthru_endpoint.c b/test/core/util/passthru_endpoint.c
index 6400845d23..0eea6749c6 100644
--- a/test/core/util/passthru_endpoint.c
+++ b/test/core/util/passthru_endpoint.c
@@ -169,23 +169,14 @@ static char *me_get_peer(grpc_endpoint *ep) {
 
 static int me_get_fd(grpc_endpoint *ep) { return -1; }
 
-static grpc_workqueue *me_get_workqueue(grpc_endpoint *ep) { return NULL; }
-
 static grpc_resource_user *me_get_resource_user(grpc_endpoint *ep) {
   half *m = (half *)ep;
   return m->resource_user;
 }
 
 static const grpc_endpoint_vtable vtable = {
-    me_read,
-    me_write,
-    me_get_workqueue,
-    me_add_to_pollset,
-    me_add_to_pollset_set,
-    me_shutdown,
-    me_destroy,
-    me_get_resource_user,
-    me_get_peer,
+    me_read,     me_write,   me_add_to_pollset,    me_add_to_pollset_set,
+    me_shutdown, me_destroy, me_get_resource_user, me_get_peer,
     me_get_fd,
 };
 
diff --git a/test/core/util/trickle_endpoint.c b/test/core/util/trickle_endpoint.c
index 69386a0718..a3f3a2a7af 100644
--- a/test/core/util/trickle_endpoint.c
+++ b/test/core/util/trickle_endpoint.c
@@ -92,11 +92,6 @@ static void te_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   gpr_mu_unlock(&te->mu);
 }
 
-static grpc_workqueue *te_get_workqueue(grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
-  return grpc_endpoint_get_workqueue(te->wrapped);
-}
-
 static void te_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
                               grpc_pollset *pollset) {
   trickle_endpoint *te = (trickle_endpoint *)ep;
@@ -155,16 +150,10 @@ static void te_finish_write(grpc_exec_ctx *exec_ctx, void *arg,
   gpr_mu_unlock(&te->mu);
 }
 
-static const grpc_endpoint_vtable vtable = {te_read,
-                                            te_write,
-                                            te_get_workqueue,
-                                            te_add_to_pollset,
-                                            te_add_to_pollset_set,
-                                            te_shutdown,
-                                            te_destroy,
-                                            te_get_resource_user,
-                                            te_get_peer,
-                                            te_get_fd};
+static const grpc_endpoint_vtable vtable = {
+    te_read,     te_write,   te_add_to_pollset,    te_add_to_pollset_set,
+    te_shutdown, te_destroy, te_get_resource_user, te_get_peer,
+    te_get_fd};
 
 grpc_endpoint *grpc_trickle_endpoint_create(grpc_endpoint *wrap,
                                             double bytes_per_second) {
diff --git a/test/cpp/microbenchmarks/bm_chttp2_transport.cc b/test/cpp/microbenchmarks/bm_chttp2_transport.cc
index 8c5413b5fd..690a3112de 100644
--- a/test/cpp/microbenchmarks/bm_chttp2_transport.cc
+++ b/test/cpp/microbenchmarks/bm_chttp2_transport.cc
@@ -60,16 +60,10 @@ auto &force_library_initialization = Library::get();
 class DummyEndpoint : public grpc_endpoint {
  public:
   DummyEndpoint() {
-    static const grpc_endpoint_vtable my_vtable = {read,
-                                                   write,
-                                                   get_workqueue,
-                                                   add_to_pollset,
-                                                   add_to_pollset_set,
-                                                   shutdown,
-                                                   destroy,
-                                                   get_resource_user,
-                                                   get_peer,
-                                                   get_fd};
+    static const grpc_endpoint_vtable my_vtable = {
+        read,     write,   add_to_pollset,    add_to_pollset_set,
+        shutdown, destroy, get_resource_user, get_peer,
+        get_fd};
     grpc_endpoint::vtable = &my_vtable;
     ru_ = grpc_resource_user_create(Library::get().rq(), "dummy_endpoint");
   }
diff --git a/test/cpp/microbenchmarks/bm_closure.cc b/test/cpp/microbenchmarks/bm_closure.cc
index d52fe4ee30..fd540e994b 100644
--- a/test/cpp/microbenchmarks/bm_closure.cc
+++ b/test/cpp/microbenchmarks/bm_closure.cc
@@ -84,12 +84,12 @@ BENCHMARK(BM_ClosureInitAgainstExecCtx);
 
 static void BM_ClosureInitAgainstCombiner(benchmark::State& state) {
   TrackCounters track_counters;
-  grpc_combiner* combiner = grpc_combiner_create(NULL);
+  grpc_combiner* combiner = grpc_combiner_create();
   grpc_closure c;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     benchmark::DoNotOptimize(grpc_closure_init(
-        &c, DoNothing, NULL, grpc_combiner_scheduler(combiner, false)));
+        &c, DoNothing, NULL, grpc_combiner_scheduler(combiner)));
   }
   GRPC_COMBINER_UNREF(&exec_ctx, combiner, "finished");
   grpc_exec_ctx_finish(&exec_ctx);
@@ -259,10 +259,9 @@ BENCHMARK(BM_TryAcquireSpinlock);
 
 static void BM_ClosureSchedOnCombiner(benchmark::State& state) {
   TrackCounters track_counters;
-  grpc_combiner* combiner = grpc_combiner_create(NULL);
+  grpc_combiner* combiner = grpc_combiner_create();
   grpc_closure c;
-  grpc_closure_init(&c, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner, false));
+  grpc_closure_init(&c, DoNothing, NULL, grpc_combiner_scheduler(combiner));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     grpc_closure_sched(&exec_ctx, &c, GRPC_ERROR_NONE);
@@ -276,13 +275,11 @@ BENCHMARK(BM_ClosureSchedOnCombiner);
 
 static void BM_ClosureSched2OnCombiner(benchmark::State& state) {
   TrackCounters track_counters;
-  grpc_combiner* combiner = grpc_combiner_create(NULL);
+  grpc_combiner* combiner = grpc_combiner_create();
   grpc_closure c1;
   grpc_closure c2;
-  grpc_closure_init(&c1, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner, false));
-  grpc_closure_init(&c2, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner, false));
+  grpc_closure_init(&c1, DoNothing, NULL, grpc_combiner_scheduler(combiner));
+  grpc_closure_init(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     grpc_closure_sched(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -297,16 +294,13 @@ BENCHMARK(BM_ClosureSched2OnCombiner);
 
 static void BM_ClosureSched3OnCombiner(benchmark::State& state) {
   TrackCounters track_counters;
-  grpc_combiner* combiner = grpc_combiner_create(NULL);
+  grpc_combiner* combiner = grpc_combiner_create();
   grpc_closure c1;
   grpc_closure c2;
   grpc_closure c3;
-  grpc_closure_init(&c1, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner, false));
-  grpc_closure_init(&c2, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner, false));
-  grpc_closure_init(&c3, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner, false));
+  grpc_closure_init(&c1, DoNothing, NULL, grpc_combiner_scheduler(combiner));
+  grpc_closure_init(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner));
+  grpc_closure_init(&c3, DoNothing, NULL, grpc_combiner_scheduler(combiner));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     grpc_closure_sched(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -322,14 +316,12 @@ BENCHMARK(BM_ClosureSched3OnCombiner);
 
 static void BM_ClosureSched2OnTwoCombiners(benchmark::State& state) {
   TrackCounters track_counters;
-  grpc_combiner* combiner1 = grpc_combiner_create(NULL);
-  grpc_combiner* combiner2 = grpc_combiner_create(NULL);
+  grpc_combiner* combiner1 = grpc_combiner_create();
+  grpc_combiner* combiner2 = grpc_combiner_create();
   grpc_closure c1;
   grpc_closure c2;
-  grpc_closure_init(&c1, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner1, false));
-  grpc_closure_init(&c2, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner2, false));
+  grpc_closure_init(&c1, DoNothing, NULL, grpc_combiner_scheduler(combiner1));
+  grpc_closure_init(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner2));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     grpc_closure_sched(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -345,20 +337,16 @@ BENCHMARK(BM_ClosureSched2OnTwoCombiners);
 
 static void BM_ClosureSched4OnTwoCombiners(benchmark::State& state) {
   TrackCounters track_counters;
-  grpc_combiner* combiner1 = grpc_combiner_create(NULL);
-  grpc_combiner* combiner2 = grpc_combiner_create(NULL);
+  grpc_combiner* combiner1 = grpc_combiner_create();
+  grpc_combiner* combiner2 = grpc_combiner_create();
   grpc_closure c1;
   grpc_closure c2;
   grpc_closure c3;
   grpc_closure c4;
-  grpc_closure_init(&c1, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner1, false));
-  grpc_closure_init(&c2, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner2, false));
-  grpc_closure_init(&c3, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner1, false));
-  grpc_closure_init(&c4, DoNothing, NULL,
-                    grpc_combiner_scheduler(combiner2, false));
+  grpc_closure_init(&c1, DoNothing, NULL, grpc_combiner_scheduler(combiner1));
+  grpc_closure_init(&c2, DoNothing, NULL, grpc_combiner_scheduler(combiner2));
+  grpc_closure_init(&c3, DoNothing, NULL, grpc_combiner_scheduler(combiner1));
+  grpc_closure_init(&c4, DoNothing, NULL, grpc_combiner_scheduler(combiner2));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (state.KeepRunning()) {
     grpc_closure_sched(&exec_ctx, &c1, GRPC_ERROR_NONE);
@@ -418,8 +406,8 @@ BENCHMARK(BM_ClosureReschedOnExecCtx);
 static void BM_ClosureReschedOnCombiner(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_combiner* combiner = grpc_combiner_create(NULL);
-  Rescheduler r(state, grpc_combiner_scheduler(combiner, false));
+  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");
@@ -431,10 +419,10 @@ BENCHMARK(BM_ClosureReschedOnCombiner);
 static void BM_ClosureReschedOnCombinerFinally(benchmark::State& state) {
   TrackCounters track_counters;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_combiner* combiner = grpc_combiner_create(NULL);
-  Rescheduler r(state, grpc_combiner_finally_scheduler(combiner, false));
-  r.ScheduleFirstAgainstDifferentScheduler(
-      &exec_ctx, grpc_combiner_scheduler(combiner, false));
+  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);