grpc 1.18.0 → 1.22.0

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

@@ -43,7 +43,6 @@
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/wakeup_fd_cv.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 #include "src/core/lib/profiling/timers.h"
 
@@ -126,7 +125,7 @@ struct grpc_fd {
   grpc_fork_fd_list* fork_fd_list;
 };
 
-/* True when GRPC_ENABLE_FORK_SUPPORT=1. We do not support fork with poll-cv */
+/* True when GRPC_ENABLE_FORK_SUPPORT=1. */
 static bool track_fds_for_fork = false;
 
 /* Only used when GRPC_ENABLE_FORK_SUPPORT=1 */
@@ -256,56 +255,6 @@ struct grpc_pollset_set {
   grpc_fd** fds;
 };
 
-/*******************************************************************************
- * condition variable polling definitions
- */
-
-#define POLLCV_THREAD_GRACE_MS 1000
-#define CV_POLL_PERIOD_MS 1000
-#define CV_DEFAULT_TABLE_SIZE 16
-
-typedef struct poll_result {
-  gpr_refcount refcount;
-  grpc_cv_node* watchers;
-  int watchcount;
-  struct pollfd* fds;
-  nfds_t nfds;
-  int retval;
-  int err;
-  int completed;
-} poll_result;
-
-typedef struct poll_args {
-  grpc_core::Thread poller_thd;
-  gpr_cv trigger;
-  int trigger_set;
-  bool harvestable;
-  gpr_cv harvest;
-  bool joinable;
-  gpr_cv join;
-  struct pollfd* fds;
-  nfds_t nfds;
-  poll_result* result;
-  struct poll_args* next;
-  struct poll_args* prev;
-} poll_args;
-
-// This is a 2-tiered cache, we mantain a hash table
-// of active poll calls, so we can wait on the result
-// of that call.  We also maintain freelists of inactive
-// poll args and of dead poller threads.
-typedef struct poll_hash_table {
-  poll_args* free_pollers;
-  poll_args** active_pollers;
-  poll_args* dead_pollers;
-  unsigned int size;
-  unsigned int count;
-} poll_hash_table;
-
-// TODO(kpayson64): Eliminate use of global non-POD variables
-poll_hash_table poll_cache;
-grpc_cv_fd_table g_cvfds;
-
 /*******************************************************************************
  * functions to track opened fds. No-ops unless track_fds_for_fork is true.
  */
@@ -367,7 +316,7 @@ static void fork_fd_list_add_wakeup_fd(grpc_cached_wakeup_fd* fd) {
 #define UNREF_BY(fd, n, reason) unref_by(fd, n, reason, __FILE__, __LINE__)
 static void ref_by(grpc_fd* fd, int n, const char* reason, const char* file,
                    int line) {
-  if (grpc_trace_fd_refcount.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
     gpr_log(GPR_DEBUG,
             "FD %d %p   ref %d %" PRIdPTR " -> %" PRIdPTR " [%s; %s:%d]",
             fd->fd, fd, n, gpr_atm_no_barrier_load(&fd->refst),
@@ -384,7 +333,7 @@ static void ref_by(grpc_fd* fd, int n) {
 #ifndef NDEBUG
 static void unref_by(grpc_fd* fd, int n, const char* reason, const char* file,
                      int line) {
-  if (grpc_trace_fd_refcount.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
     gpr_log(GPR_DEBUG,
             "FD %d %p unref %d %" PRIdPTR " -> %" PRIdPTR " [%s; %s:%d]",
             fd->fd, fd, n, gpr_atm_no_barrier_load(&fd->refst),
@@ -612,7 +561,7 @@ static void fd_notify_on_write(grpc_fd* fd, grpc_closure* closure) {
 }
 
 static void fd_notify_on_error(grpc_fd* fd, grpc_closure* closure) {
-  if (grpc_polling_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     gpr_log(GPR_ERROR, "Polling engine does not support tracking errors.");
   }
   GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_CANCELLED);
@@ -631,7 +580,7 @@ static void fd_set_writable(grpc_fd* fd) {
 }
 
 static void fd_set_error(grpc_fd* fd) {
-  if (grpc_polling_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     gpr_log(GPR_ERROR, "Polling engine does not support tracking errors.");
   }
 }
@@ -1063,7 +1012,7 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
       r = grpc_poll_function(pfds, pfd_count, timeout);
       GRPC_SCHEDULING_END_BLOCKING_REGION;
 
-      if (grpc_polling_trace.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
         gpr_log(GPR_INFO, "%p poll=%d", pollset, r);
       }
 
@@ -1087,7 +1036,7 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
         }
       } else {
         if (pfds[0].revents & POLLIN_CHECK) {
-          if (grpc_polling_trace.enabled()) {
+          if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
             gpr_log(GPR_INFO, "%p: got_wakeup", pollset);
           }
           work_combine_error(
@@ -1097,7 +1046,7 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
           if (watchers[i].fd == nullptr) {
             fd_end_poll(&watchers[i], 0, 0);
           } else {
-            if (grpc_polling_trace.enabled()) {
+            if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
               gpr_log(GPR_INFO, "%p got_event: %d r:%d w:%d [%d]", pollset,
                       pfds[i].fd, (pfds[i].revents & POLLIN_CHECK) != 0,
                       (pfds[i].revents & POLLOUT_CHECK) != 0, pfds[i].revents);
@@ -1364,431 +1313,20 @@ static void pollset_set_del_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
 }
 
 /*******************************************************************************
- * Condition Variable polling extensions
+ * event engine binding
  */
 
-static void run_poll(void* args);
-static void cache_poller_locked(poll_args* args);
-static void cache_harvest_locked();
-
-static void cache_insert_locked(poll_args* args) {
-  uint32_t key = gpr_murmur_hash3(args->fds, args->nfds * sizeof(struct pollfd),
-                                  0xDEADBEEF);
-  key = key % poll_cache.size;
-  if (poll_cache.active_pollers[key]) {
-    poll_cache.active_pollers[key]->prev = args;
-  }
-  args->next = poll_cache.active_pollers[key];
-  args->prev = nullptr;
-  poll_cache.active_pollers[key] = args;
-  poll_cache.count++;
-}
-
-static void init_result(poll_args* pargs) {
-  pargs->result = static_cast<poll_result*>(gpr_malloc(sizeof(poll_result)));
-  gpr_ref_init(&pargs->result->refcount, 1);
-  pargs->result->watchers = nullptr;
-  pargs->result->watchcount = 0;
-  pargs->result->fds = static_cast<struct pollfd*>(
-      gpr_malloc(sizeof(struct pollfd) * pargs->nfds));
-  memcpy(pargs->result->fds, pargs->fds, sizeof(struct pollfd) * pargs->nfds);
-  pargs->result->nfds = pargs->nfds;
-  pargs->result->retval = 0;
-  pargs->result->err = 0;
-  pargs->result->completed = 0;
-}
-
-// Creates a poll_args object for a given arguments to poll().
-// This object may return a poll_args in the cache.
-static poll_args* get_poller_locked(struct pollfd* fds, nfds_t count) {
-  uint32_t key =
-      gpr_murmur_hash3(fds, count * sizeof(struct pollfd), 0xDEADBEEF);
-  key = key % poll_cache.size;
-  poll_args* curr = poll_cache.active_pollers[key];
-  while (curr) {
-    if (curr->nfds == count &&
-        memcmp(curr->fds, fds, count * sizeof(struct pollfd)) == 0) {
-      gpr_free(fds);
-      return curr;
-    }
-    curr = curr->next;
-  }
-
-  if (poll_cache.free_pollers) {
-    poll_args* pargs = poll_cache.free_pollers;
-    poll_cache.free_pollers = pargs->next;
-    if (poll_cache.free_pollers) {
-      poll_cache.free_pollers->prev = nullptr;
-    }
-    pargs->fds = fds;
-    pargs->nfds = count;
-    pargs->next = nullptr;
-    pargs->prev = nullptr;
-    init_result(pargs);
-    cache_poller_locked(pargs);
-    return pargs;
-  }
-
-  poll_args* pargs =
-      static_cast<poll_args*>(gpr_malloc(sizeof(struct poll_args)));
-  gpr_cv_init(&pargs->trigger);
-  gpr_cv_init(&pargs->harvest);
-  gpr_cv_init(&pargs->join);
-  pargs->harvestable = false;
-  pargs->joinable = false;
-  pargs->fds = fds;
-  pargs->nfds = count;
-  pargs->next = nullptr;
-  pargs->prev = nullptr;
-  pargs->trigger_set = 0;
-  init_result(pargs);
-  cache_poller_locked(pargs);
-  gpr_ref(&g_cvfds.pollcount);
-  pargs->poller_thd = grpc_core::Thread("grpc_poller", &run_poll, pargs);
-  pargs->poller_thd.Start();
-  return pargs;
-}
-
-static void cache_delete_locked(poll_args* args) {
-  if (!args->prev) {
-    uint32_t key = gpr_murmur_hash3(
-        args->fds, args->nfds * sizeof(struct pollfd), 0xDEADBEEF);
-    key = key % poll_cache.size;
-    GPR_ASSERT(poll_cache.active_pollers[key] == args);
-    poll_cache.active_pollers[key] = args->next;
-  } else {
-    args->prev->next = args->next;
-  }
-
-  if (args->next) {
-    args->next->prev = args->prev;
-  }
-
-  poll_cache.count--;
-  if (poll_cache.free_pollers) {
-    poll_cache.free_pollers->prev = args;
-  }
-  args->prev = nullptr;
-  args->next = poll_cache.free_pollers;
-  gpr_free(args->fds);
-  poll_cache.free_pollers = args;
-}
-
-static void cache_poller_locked(poll_args* args) {
-  if (poll_cache.count + 1 > poll_cache.size / 2) {
-    poll_args** old_active_pollers = poll_cache.active_pollers;
-    poll_cache.size = poll_cache.size * 2;
-    poll_cache.count = 0;
-    poll_cache.active_pollers =
-        static_cast<poll_args**>(gpr_malloc(sizeof(void*) * poll_cache.size));
-    for (unsigned int i = 0; i < poll_cache.size; i++) {
-      poll_cache.active_pollers[i] = nullptr;
-    }
-    for (unsigned int i = 0; i < poll_cache.size / 2; i++) {
-      poll_args* curr = old_active_pollers[i];
-      poll_args* next = nullptr;
-      while (curr) {
-        next = curr->next;
-        cache_insert_locked(curr);
-        curr = next;
-      }
-    }
-    gpr_free(old_active_pollers);
-  }
-
-  cache_insert_locked(args);
-}
-
-static void cache_destroy_locked(poll_args* args) {
-  if (args->next) {
-    args->next->prev = args->prev;
-  }
-
-  if (args->prev) {
-    args->prev->next = args->next;
-  } else {
-    poll_cache.free_pollers = args->next;
-  }
-
-  // Now move this args to the dead poller list for later join
-  if (poll_cache.dead_pollers != nullptr) {
-    poll_cache.dead_pollers->prev = args;
-  }
-  args->prev = nullptr;
-  args->next = poll_cache.dead_pollers;
-  poll_cache.dead_pollers = args;
-}
-
-static void cache_harvest_locked() {
-  while (poll_cache.dead_pollers) {
-    poll_args* args = poll_cache.dead_pollers;
-    poll_cache.dead_pollers = poll_cache.dead_pollers->next;
-    // Keep the list consistent in case new dead pollers get added when we
-    // release the lock below to wait on joining
-    if (poll_cache.dead_pollers) {
-      poll_cache.dead_pollers->prev = nullptr;
-    }
-    args->harvestable = true;
-    gpr_cv_signal(&args->harvest);
-    while (!args->joinable) {
-      gpr_cv_wait(&args->join, &g_cvfds.mu,
-                  gpr_inf_future(GPR_CLOCK_MONOTONIC));
-    }
-    args->poller_thd.Join();
-    gpr_free(args);
-  }
-}
-
-static void decref_poll_result(poll_result* res) {
-  if (gpr_unref(&res->refcount)) {
-    GPR_ASSERT(!res->watchers);
-    gpr_free(res->fds);
-    gpr_free(res);
-  }
-}
-
-void remove_cvn(grpc_cv_node** head, grpc_cv_node* target) {
-  if (target->next) {
-    target->next->prev = target->prev;
-  }
-
-  if (target->prev) {
-    target->prev->next = target->next;
-  } else {
-    *head = target->next;
-  }
-}
-
-gpr_timespec thread_grace;
-
-// Poll in a background thread
-static void run_poll(void* args) {
-  poll_args* pargs = static_cast<poll_args*>(args);
-  while (1) {
-    poll_result* result = pargs->result;
-    int retval = g_cvfds.poll(result->fds, result->nfds, CV_POLL_PERIOD_MS);
-    gpr_mu_lock(&g_cvfds.mu);
-    cache_harvest_locked();
-    if (retval != 0) {
-      result->completed = 1;
-      result->retval = retval;
-      result->err = errno;
-      grpc_cv_node* watcher = result->watchers;
-      while (watcher) {
-        gpr_cv_signal(watcher->cv);
-        watcher = watcher->next;
-      }
-    }
-    if (result->watchcount == 0 || result->completed) {
-      cache_delete_locked(pargs);
-      decref_poll_result(result);
-      // Leave this polling thread alive for a grace period to do another poll()
-      // op
-      gpr_timespec deadline = gpr_now(GPR_CLOCK_MONOTONIC);
-      deadline = gpr_time_add(deadline, thread_grace);
-      pargs->trigger_set = 0;
-      gpr_cv_wait(&pargs->trigger, &g_cvfds.mu, deadline);
-      cache_harvest_locked();
-      if (!pargs->trigger_set) {
-        cache_destroy_locked(pargs);
-        break;
-      }
-    }
-    gpr_mu_unlock(&g_cvfds.mu);
-  }
-
-  if (gpr_unref(&g_cvfds.pollcount)) {
-    gpr_cv_signal(&g_cvfds.shutdown_cv);
-  }
-  while (!pargs->harvestable) {
-    gpr_cv_wait(&pargs->harvest, &g_cvfds.mu,
-                gpr_inf_future(GPR_CLOCK_MONOTONIC));
-  }
-  pargs->joinable = true;
-  gpr_cv_signal(&pargs->join);
-  gpr_mu_unlock(&g_cvfds.mu);
-}
-
-// This function overrides poll() to handle condition variable wakeup fds
-static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
-  if (timeout == 0) {
-    // Don't bother using background threads for polling if timeout is 0,
-    // poll-cv might not wait for a poll to return otherwise.
-    // https://github.com/grpc/grpc/issues/13298
-    return poll(fds, nfds, 0);
-  }
-  unsigned int i;
-  int res, idx;
-  grpc_cv_node* pollcv;
-  int skip_poll = 0;
-  nfds_t nsockfds = 0;
-  poll_result* result = nullptr;
-  gpr_mu_lock(&g_cvfds.mu);
-  cache_harvest_locked();
-  pollcv = static_cast<grpc_cv_node*>(gpr_malloc(sizeof(grpc_cv_node)));
-  pollcv->next = nullptr;
-  gpr_cv pollcv_cv;
-  gpr_cv_init(&pollcv_cv);
-  pollcv->cv = &pollcv_cv;
-  grpc_cv_node* fd_cvs =
-      static_cast<grpc_cv_node*>(gpr_malloc(nfds * sizeof(grpc_cv_node)));
-
-  for (i = 0; i < nfds; i++) {
-    fds[i].revents = 0;
-    if (fds[i].fd < 0 && (fds[i].events & POLLIN)) {
-      idx = GRPC_FD_TO_IDX(fds[i].fd);
-      fd_cvs[i].cv = &pollcv_cv;
-      fd_cvs[i].prev = nullptr;
-      fd_cvs[i].next = g_cvfds.cvfds[idx].cvs;
-      if (g_cvfds.cvfds[idx].cvs) {
-        g_cvfds.cvfds[idx].cvs->prev = &(fd_cvs[i]);
-      }
-      g_cvfds.cvfds[idx].cvs = &(fd_cvs[i]);
-      // Don't bother polling if a wakeup fd is ready
-      if (g_cvfds.cvfds[idx].is_set) {
-        skip_poll = 1;
-      }
-    } else if (fds[i].fd >= 0) {
-      nsockfds++;
-    }
-  }
+static bool is_any_background_poller_thread(void) { return false; }
 
-  gpr_timespec deadline = gpr_now(GPR_CLOCK_MONOTONIC);
-  if (timeout < 0) {
-    deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
-  } else {
-    deadline =
-        gpr_time_add(deadline, gpr_time_from_millis(timeout, GPR_TIMESPAN));
-  }
-
-  res = 0;
-  if (!skip_poll && nsockfds > 0) {
-    struct pollfd* pollfds = static_cast<struct pollfd*>(
-        gpr_malloc(sizeof(struct pollfd) * nsockfds));
-    idx = 0;
-    for (i = 0; i < nfds; i++) {
-      if (fds[i].fd >= 0) {
-        pollfds[idx].fd = fds[i].fd;
-        pollfds[idx].events = fds[i].events;
-        pollfds[idx].revents = 0;
-        idx++;
-      }
-    }
-    poll_args* pargs = get_poller_locked(pollfds, nsockfds);
-    result = pargs->result;
-    pollcv->next = result->watchers;
-    pollcv->prev = nullptr;
-    if (result->watchers) {
-      result->watchers->prev = pollcv;
-    }
-    result->watchers = pollcv;
-    result->watchcount++;
-    gpr_ref(&result->refcount);
-
-    pargs->trigger_set = 1;
-    gpr_cv_signal(&pargs->trigger);
-    gpr_cv_wait(&pollcv_cv, &g_cvfds.mu, deadline);
-    cache_harvest_locked();
-    res = result->retval;
-    errno = result->err;
-    result->watchcount--;
-    remove_cvn(&result->watchers, pollcv);
-  } else if (!skip_poll) {
-    gpr_cv_wait(&pollcv_cv, &g_cvfds.mu, deadline);
-    cache_harvest_locked();
-  }
-
-  idx = 0;
-  for (i = 0; i < nfds; i++) {
-    if (fds[i].fd < 0 && (fds[i].events & POLLIN)) {
-      remove_cvn(&g_cvfds.cvfds[GRPC_FD_TO_IDX(fds[i].fd)].cvs, &(fd_cvs[i]));
-      if (g_cvfds.cvfds[GRPC_FD_TO_IDX(fds[i].fd)].is_set) {
-        fds[i].revents = POLLIN;
-        if (res >= 0) res++;
-      }
-    } else if (!skip_poll && fds[i].fd >= 0 && result->completed) {
-      fds[i].revents = result->fds[idx].revents;
-      idx++;
-    }
-  }
-
-  gpr_free(fd_cvs);
-  gpr_free(pollcv);
-  if (result) {
-    decref_poll_result(result);
-  }
-
-  gpr_mu_unlock(&g_cvfds.mu);
-
-  return res;
-}
-
-static void global_cv_fd_table_init() {
-  gpr_mu_init(&g_cvfds.mu);
-  gpr_mu_lock(&g_cvfds.mu);
-  gpr_cv_init(&g_cvfds.shutdown_cv);
-  gpr_ref_init(&g_cvfds.pollcount, 1);
-  g_cvfds.size = CV_DEFAULT_TABLE_SIZE;
-  g_cvfds.cvfds = static_cast<grpc_fd_node*>(
-      gpr_malloc(sizeof(grpc_fd_node) * CV_DEFAULT_TABLE_SIZE));
-  g_cvfds.free_fds = nullptr;
-  thread_grace = gpr_time_from_millis(POLLCV_THREAD_GRACE_MS, GPR_TIMESPAN);
-  for (int i = 0; i < CV_DEFAULT_TABLE_SIZE; i++) {
-    g_cvfds.cvfds[i].is_set = 0;
-    g_cvfds.cvfds[i].cvs = nullptr;
-    g_cvfds.cvfds[i].next_free = g_cvfds.free_fds;
-    g_cvfds.free_fds = &g_cvfds.cvfds[i];
-  }
-  // Override the poll function with one that supports cvfds
-  g_cvfds.poll = grpc_poll_function;
-  grpc_poll_function = &cvfd_poll;
-
-  // Initialize the cache
-  poll_cache.size = 32;
-  poll_cache.count = 0;
-  poll_cache.free_pollers = nullptr;
-  poll_cache.active_pollers =
-      static_cast<poll_args**>(gpr_malloc(sizeof(void*) * 32));
-  for (unsigned int i = 0; i < poll_cache.size; i++) {
-    poll_cache.active_pollers[i] = nullptr;
-  }
-  poll_cache.dead_pollers = nullptr;
-
-  gpr_mu_unlock(&g_cvfds.mu);
-}
+static void shutdown_background_closure(void) {}
 
-static void global_cv_fd_table_shutdown() {
-  gpr_mu_lock(&g_cvfds.mu);
-  // Attempt to wait for all abandoned poll() threads to terminate
-  // Not doing so will result in reported memory leaks
-  if (!gpr_unref(&g_cvfds.pollcount)) {
-    int res = gpr_cv_wait(&g_cvfds.shutdown_cv, &g_cvfds.mu,
-                          gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
-                                       gpr_time_from_seconds(3, GPR_TIMESPAN)));
-    GPR_ASSERT(res == 0);
-  }
-  gpr_cv_destroy(&g_cvfds.shutdown_cv);
-  grpc_poll_function = g_cvfds.poll;
-  gpr_free(g_cvfds.cvfds);
-
-  cache_harvest_locked();
-  gpr_free(poll_cache.active_pollers);
-
-  gpr_mu_unlock(&g_cvfds.mu);
-  gpr_mu_destroy(&g_cvfds.mu);
+static bool add_closure_to_background_poller(grpc_closure* closure,
+                                             grpc_error* error) {
+  return false;
 }
 
-/*******************************************************************************
- * event engine binding
- */
-
-static void shutdown_background_closure(void) {}
-
 static void shutdown_engine(void) {
   pollset_global_shutdown();
-  if (grpc_cv_wakeup_fds_enabled()) {
-    global_cv_fd_table_shutdown();
-  }
   if (track_fds_for_fork) {
     gpr_mu_destroy(&fork_fd_list_mu);
     grpc_core::Fork::SetResetChildPollingEngineFunc(nullptr);
@@ -1828,8 +1366,10 @@ static const grpc_event_engine_vtable vtable = {
     pollset_set_add_fd,
     pollset_set_del_fd,
 
+    is_any_background_poller_thread,
     shutdown_background_closure,
     shutdown_engine,
+    add_closure_to_background_poller,
 };
 
 /* Called by the child process's post-fork handler to close open fds, including
@@ -1869,15 +1409,4 @@ const grpc_event_engine_vtable* grpc_init_poll_posix(bool explicit_request) {
   return &vtable;
 }
 
-const grpc_event_engine_vtable* grpc_init_poll_cv_posix(bool explicit_request) {
-  global_cv_fd_table_init();
-  grpc_enable_cv_wakeup_fds(1);
-  if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {
-    global_cv_fd_table_shutdown();
-    grpc_enable_cv_wakeup_fds(0);
-    return nullptr;
-  }
-  return &vtable;
-}
-
 #endif /* GRPC_POSIX_SOCKET_EV_POLL */

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

@@ -31,31 +31,36 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
 #include "src/core/lib/iomgr/ev_epollex_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
 
-grpc_core::TraceFlag grpc_polling_trace(false,
-                                        "polling"); /* Disabled by default */
+GPR_GLOBAL_CONFIG_DEFINE_STRING(
+    grpc_poll_strategy, "all",
+    "Declares which polling engines to try when starting gRPC. "
+    "This is a comma-separated list of engines, which are tried in priority "
+    "order first -> last.")
+
+grpc_core::DebugOnlyTraceFlag grpc_polling_trace(
+    false, "polling"); /* Disabled by default */
 
 /* Traces fd create/close operations */
-grpc_core::TraceFlag grpc_fd_trace(false, "fd_trace");
+grpc_core::DebugOnlyTraceFlag grpc_fd_trace(false, "fd_trace");
 grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount(false, "fd_refcount");
 grpc_core::DebugOnlyTraceFlag grpc_polling_api_trace(false, "polling_api");
 
-#ifndef NDEBUG
-
 // Polling API trace only enabled in debug builds
+#ifndef NDEBUG
 #define GRPC_POLLING_API_TRACE(format, ...)                  \
-  if (grpc_polling_api_trace.enabled()) {                    \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_api_trace)) {     \
     gpr_log(GPR_INFO, "(polling-api) " format, __VA_ARGS__); \
   }
 #else
 #define GRPC_POLLING_API_TRACE(...)
-#endif
+#endif  // NDEBUG
 
 /** Default poll() function - a pointer so that it can be overridden by some
  *  tests */
@@ -66,7 +71,7 @@ int aix_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
   return poll(fds, nfds, timeout);
 }
 grpc_poll_function_type grpc_poll_function = aix_poll;
-#endif
+#endif  // GPR_AIX
 
 grpc_wakeup_fd grpc_global_wakeup_fd;
 
@@ -126,10 +131,9 @@ static event_engine_factory g_factories[] = {
     {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
     {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
     {"epollex", grpc_init_epollex_linux}, {"epoll1", grpc_init_epoll1_linux},
-    {"poll", grpc_init_poll_posix},       {"poll-cv", grpc_init_poll_cv_posix},
-    {"none", init_non_polling},           {ENGINE_TAIL_CUSTOM, nullptr},
+    {"poll", grpc_init_poll_posix},       {"none", init_non_polling},
+    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
     {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
-    {ENGINE_TAIL_CUSTOM, nullptr},
 };
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
@@ -206,14 +210,11 @@ void grpc_register_event_engine_factory(const char* name,
 const char* grpc_get_poll_strategy_name() { return g_poll_strategy_name; }
 
 void grpc_event_engine_init(void) {
-  char* s = gpr_getenv("GRPC_POLL_STRATEGY");
-  if (s == nullptr) {
-    s = gpr_strdup("all");
-  }
+  grpc_core::UniquePtr<char> value = GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
 
   char** strings = nullptr;
   size_t nstrings = 0;
-  split(s, &strings, &nstrings);
+  split(value.get(), &strings, &nstrings);
 
   for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
     try_engine(strings[i]);
@@ -225,10 +226,10 @@ void grpc_event_engine_init(void) {
   gpr_free(strings);
 
   if (g_event_engine == nullptr) {
-    gpr_log(GPR_ERROR, "No event engine could be initialized from %s", s);
+    gpr_log(GPR_ERROR, "No event engine could be initialized from %s",
+            value.get());
     abort();
   }
-  gpr_free(s);
 }
 
 void grpc_event_engine_shutdown(void) {
@@ -399,6 +400,15 @@ void grpc_pollset_set_del_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
   g_event_engine->pollset_set_del_fd(pollset_set, fd);
 }
 
+bool grpc_is_any_background_poller_thread(void) {
+  return g_event_engine->is_any_background_poller_thread();
+}
+
+bool grpc_add_closure_to_background_poller(grpc_closure* closure,
+                                           grpc_error* error) {
+  return g_event_engine->add_closure_to_background_poller(closure, error);
+}
+
 void grpc_shutdown_background_closure(void) {
   g_event_engine->shutdown_background_closure();
 }