grpc 1.53.1 → 1.54.0

data/src/core/lib/gpr/log.cc

@@ -21,27 +21,21 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/global_config.h"
 
 #ifndef GPR_DEFAULT_LOG_VERBOSITY_STRING
 #define GPR_DEFAULT_LOG_VERBOSITY_STRING "ERROR"
 #endif  // !GPR_DEFAULT_LOG_VERBOSITY_STRING
 
-GPR_GLOBAL_CONFIG_DEFINE_STRING(grpc_verbosity,
-                                GPR_DEFAULT_LOG_VERBOSITY_STRING,
-                                "Default gRPC logging verbosity")
-GPR_GLOBAL_CONFIG_DEFINE_STRING(grpc_stacktrace_minloglevel, "",
-                                "Messages logged at the same or higher level "
-                                "than this will print stacktrace")
-
 static constexpr gpr_atm GPR_LOG_SEVERITY_UNSET = GPR_LOG_SEVERITY_ERROR + 10;
 static constexpr gpr_atm GPR_LOG_SEVERITY_NONE = GPR_LOG_SEVERITY_ERROR + 11;
 
@@ -106,42 +100,35 @@ void gpr_set_log_verbosity(gpr_log_severity min_severity_to_print) {
                            (gpr_atm)min_severity_to_print);
 }
 
-static gpr_atm parse_log_severity(const char* str, gpr_atm error_value) {
-  if (gpr_stricmp(str, "DEBUG") == 0) {
-    return GPR_LOG_SEVERITY_DEBUG;
-  } else if (gpr_stricmp(str, "INFO") == 0) {
-    return GPR_LOG_SEVERITY_INFO;
-  } else if (gpr_stricmp(str, "ERROR") == 0) {
-    return GPR_LOG_SEVERITY_ERROR;
-  } else if (gpr_stricmp(str, "NONE") == 0) {
-    return GPR_LOG_SEVERITY_NONE;
-  } else {
-    return error_value;
-  }
+static gpr_atm parse_log_severity(absl::string_view str, gpr_atm error_value) {
+  if (absl::EqualsIgnoreCase(str, "DEBUG")) return GPR_LOG_SEVERITY_DEBUG;
+  if (absl::EqualsIgnoreCase(str, "INFO")) return GPR_LOG_SEVERITY_INFO;
+  if (absl::EqualsIgnoreCase(str, "ERROR")) return GPR_LOG_SEVERITY_ERROR;
+  if (absl::EqualsIgnoreCase(str, "NONE")) return GPR_LOG_SEVERITY_NONE;
+  return error_value;
 }
 
 void gpr_log_verbosity_init() {
   // init verbosity when it hasn't been set
   if ((gpr_atm_no_barrier_load(&g_min_severity_to_print)) ==
       GPR_LOG_SEVERITY_UNSET) {
-    grpc_core::UniquePtr<char> verbosity =
-        GPR_GLOBAL_CONFIG_GET(grpc_verbosity);
+    auto verbosity = grpc_core::ConfigVars::Get().Verbosity();
     gpr_atm min_severity_to_print = GPR_LOG_SEVERITY_ERROR;
-    if (strlen(verbosity.get()) > 0) {
+    if (!verbosity.empty()) {
       min_severity_to_print =
-          parse_log_severity(verbosity.get(), min_severity_to_print);
+          parse_log_severity(verbosity, min_severity_to_print);
     }
     gpr_atm_no_barrier_store(&g_min_severity_to_print, min_severity_to_print);
   }
   // init stacktrace_minloglevel when it hasn't been set
   if ((gpr_atm_no_barrier_load(&g_min_severity_to_print_stacktrace)) ==
       GPR_LOG_SEVERITY_UNSET) {
-    grpc_core::UniquePtr<char> stacktrace_minloglevel =
-        GPR_GLOBAL_CONFIG_GET(grpc_stacktrace_minloglevel);
+    auto stacktrace_minloglevel =
+        grpc_core::ConfigVars::Get().StacktraceMinloglevel();
     gpr_atm min_severity_to_print_stacktrace = GPR_LOG_SEVERITY_NONE;
-    if (strlen(stacktrace_minloglevel.get()) > 0) {
+    if (!stacktrace_minloglevel.empty()) {
       min_severity_to_print_stacktrace = parse_log_severity(
-          stacktrace_minloglevel.get(), min_severity_to_print_stacktrace);
+          stacktrace_minloglevel, min_severity_to_print_stacktrace);
     }
     gpr_atm_no_barrier_store(&g_min_severity_to_print_stacktrace,
                              min_severity_to_print_stacktrace);

data/src/core/lib/gprpp/fork.cc

@@ -24,8 +24,8 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/event_engine/thread_local.h"
-#include "src/core/lib/gprpp/global_config_env.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 
 //
@@ -33,16 +33,6 @@
 //       AROUND VERY SPECIFIC USE CASES.
 //
 
-#ifdef GRPC_ENABLE_FORK_SUPPORT
-#define GRPC_ENABLE_FORK_SUPPORT_DEFAULT true
-#else
-#define GRPC_ENABLE_FORK_SUPPORT_DEFAULT false
-#endif  // GRPC_ENABLE_FORK_SUPPORT
-
-GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_enable_fork_support,
-                              GRPC_ENABLE_FORK_SUPPORT_DEFAULT,
-                              "Enable fork support");
-
 namespace grpc_core {
 namespace {
 // The exec_ctx_count has 2 modes, blocked and unblocked.
@@ -67,7 +57,6 @@ class ExecCtxState {
     // EventEngine is expected to terminate all threads before fork, and so this
     // extra work is unnecessary
     if (grpc_event_engine::experimental::ThreadLocal::IsEventEngineThread()) {
-      gpr_atm_no_barrier_fetch_add(&count_, 1);
       return;
     }
     gpr_atm count = gpr_atm_no_barrier_load(&count_);
@@ -89,7 +78,12 @@ class ExecCtxState {
     }
   }
 
-  void DecExecCtxCount() { gpr_atm_no_barrier_fetch_add(&count_, -1); }
+  void DecExecCtxCount() {
+    if (grpc_event_engine::experimental::ThreadLocal::IsEventEngineThread()) {
+      return;
+    }
+    gpr_atm_no_barrier_fetch_add(&count_, -1);
+  }
 
   bool BlockExecCtx() {
     // Assumes there is an active ExecCtx when this function is called
@@ -172,7 +166,7 @@ class ThreadState {
 
 void Fork::GlobalInit() {
   if (!override_enabled_) {
-    support_enabled_.store(GPR_GLOBAL_CONFIG_GET(grpc_enable_fork_support),
+    support_enabled_.store(ConfigVars::Get().EnableForkSupport(),
                            std::memory_order_relaxed);
   }
 }

data/src/core/lib/gprpp/orphanable.h

@@ -69,7 +69,7 @@ inline OrphanablePtr<T> MakeOrphanable(Args&&... args) {
 }
 
 // A type of Orphanable with internal ref-counting.
-template <typename Child, UnrefBehavior UnrefBehaviorArg = kUnrefDelete>
+template <typename Child, typename UnrefBehavior = UnrefDelete>
 class InternallyRefCounted : public Orphanable {
  public:
   // Not copyable nor movable.
@@ -99,12 +99,12 @@ class InternallyRefCounted : public Orphanable {
 
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
+      unref_behavior_(static_cast<Child*>(this));
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
+      unref_behavior_(static_cast<Child*>(this));
     }
   }
 
@@ -115,6 +115,7 @@ class InternallyRefCounted : public Orphanable {
   }
 
   RefCount refs_;
+  GPR_NO_UNIQUE_ADDRESS UnrefBehavior unref_behavior_;
 };
 
 }  // namespace grpc_core

data/src/core/lib/gprpp/per_cpu.h

@@ -17,7 +17,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <algorithm>
 #include <cstddef>
+#include <limits>
 #include <memory>
 
 #include <grpc/support/cpu.h>
@@ -29,7 +31,11 @@ namespace grpc_core {
 template <typename T>
 class PerCpu {
  public:
-  T& this_cpu() { return data_[ExecCtx::Get()->starting_cpu()]; }
+  explicit PerCpu(size_t max = std::numeric_limits<size_t>::max())
+      : cpus_(std::min<size_t>(max, gpr_cpu_num_cores())),
+        data_{new T[cpus_]} {}
+
+  T& this_cpu() { return data_[ExecCtx::Get()->starting_cpu() % cpus_]; }
 
   T* begin() { return data_.get(); }
   T* end() { return data_.get() + cpus_; }
@@ -37,8 +43,8 @@ class PerCpu {
   const T* end() const { return data_.get() + cpus_; }
 
  private:
-  const size_t cpus_ = gpr_cpu_num_cores();
-  std::unique_ptr<T[]> data_{new T[cpus_]};
+  const size_t cpus_;
+  std::unique_ptr<T[]> data_;
 };
 
 }  // namespace grpc_core

data/src/core/lib/gprpp/{thd_posix.cc → posix/thd.cc}

@@ -20,6 +20,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include <grpc/support/time.h>
 
 #ifdef GPR_POSIX_SYNC
@@ -34,7 +36,9 @@
 #include <grpc/support/thd_id.h>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/fork.h"
+#include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/thd.h"
 
 namespace grpc_core {
@@ -106,49 +110,52 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
       GPR_ASSERT(pthread_attr_setstacksize(&attr, stack_size) == 0);
     }
 
-    *success = (pthread_create(
-                    &pthread_id_, &attr,
-                    [](void* v) -> void* {
-                      thd_arg arg = *static_cast<thd_arg*>(v);
-                      free(v);
-                      if (arg.name != nullptr) {
+    int pthread_create_err = pthread_create(
+        &pthread_id_, &attr,
+        [](void* v) -> void* {
+          thd_arg arg = *static_cast<thd_arg*>(v);
+          free(v);
+          if (arg.name != nullptr) {
 #if GPR_APPLE_PTHREAD_NAME
-                        // Apple supports 64 characters, and will
-                        // truncate if it's longer.
-                        pthread_setname_np(arg.name);
+            // Apple supports 64 characters, and will
+            // truncate if it's longer.
+            pthread_setname_np(arg.name);
 #elif GPR_LINUX_PTHREAD_NAME
-                        // Linux supports 16 characters max, and will
-                        // error if it's longer.
-                        char buf[16];
-                        size_t buf_len = GPR_ARRAY_SIZE(buf) - 1;
-                        strncpy(buf, arg.name, buf_len);
-                        buf[buf_len] = '\0';
-                        pthread_setname_np(pthread_self(), buf);
+            // Linux supports 16 characters max, and will
+            // error if it's longer.
+            char buf[16];
+            size_t buf_len = GPR_ARRAY_SIZE(buf) - 1;
+            strncpy(buf, arg.name, buf_len);
+            buf[buf_len] = '\0';
+            pthread_setname_np(pthread_self(), buf);
 #endif  // GPR_APPLE_PTHREAD_NAME
-                      }
-
-                      gpr_mu_lock(&arg.thread->mu_);
-                      while (!arg.thread->started_) {
-                        gpr_cv_wait(&arg.thread->ready_, &arg.thread->mu_,
-                                    gpr_inf_future(GPR_CLOCK_MONOTONIC));
-                      }
-                      gpr_mu_unlock(&arg.thread->mu_);
-
-                      if (!arg.joinable) {
-                        delete arg.thread;
-                      }
-
-                      (*arg.body)(arg.arg);
-                      if (arg.tracked) {
-                        Fork::DecThreadCount();
-                      }
-                      return nullptr;
-                    },
-                    info) == 0);
+          }
+
+          gpr_mu_lock(&arg.thread->mu_);
+          while (!arg.thread->started_) {
+            gpr_cv_wait(&arg.thread->ready_, &arg.thread->mu_,
+                        gpr_inf_future(GPR_CLOCK_MONOTONIC));
+          }
+          gpr_mu_unlock(&arg.thread->mu_);
+
+          if (!arg.joinable) {
+            delete arg.thread;
+          }
+
+          (*arg.body)(arg.arg);
+          if (arg.tracked) {
+            Fork::DecThreadCount();
+          }
+          return nullptr;
+        },
+        info);
+    *success = (pthread_create_err == 0);
 
     GPR_ASSERT(pthread_attr_destroy(&attr) == 0);
 
     if (!(*success)) {
+      gpr_log(GPR_ERROR, "pthread_create failed: %s",
+              StrError(pthread_create_err).c_str());
       // don't use gpr_free, as this was allocated using malloc (see above)
       free(info);
       if (options.tracked()) {
@@ -169,7 +176,12 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
     gpr_mu_unlock(&mu_);
   }
 
-  void Join() override { pthread_join(pthread_id_, nullptr); }
+  void Join() override {
+    int pthread_join_err = pthread_join(pthread_id_, nullptr);
+    if (pthread_join_err != 0) {
+      Crash("pthread_join failed: " + StrError(pthread_join_err));
+    }
+  }
 
  private:
   gpr_mu mu_;

data/src/core/lib/gprpp/ref_counted.h

@@ -213,41 +213,34 @@ class NonPolymorphicRefCount {
 };
 
 // Behavior of RefCounted<> upon ref count reaching 0.
-enum UnrefBehavior {
-  // Default behavior: Delete the object.
-  kUnrefDelete,
-  // Do not delete the object upon unref.  This is useful in cases where all
-  // existing objects must be tracked in a registry but the object's entry in
-  // the registry cannot be removed from the object's dtor due to
-  // synchronization issues.  In this case, the registry can be cleaned up
-  // later by identifying entries for which RefIfNonZero() returns null.
-  kUnrefNoDelete,
-  // Call the object's dtor but do not delete it.  This is useful for cases
-  // where the object is stored in memory allocated elsewhere (e.g., the call
-  // arena).
-  kUnrefCallDtor,
-};
-
-namespace internal {
-template <typename T, UnrefBehavior UnrefBehaviorArg>
-class Delete;
 
-template <typename T>
-class Delete<T, kUnrefDelete> {
- public:
-  explicit Delete(T* t) { delete t; }
+// Default behavior: Delete the object.
+struct UnrefDelete {
+  template <typename T>
+  void operator()(T* p) {
+    delete p;
+  }
 };
-template <typename T>
-class Delete<T, kUnrefNoDelete> {
- public:
-  explicit Delete(T* /*t*/) {}
+
+// Do not delete the object upon unref.  This is useful in cases where all
+// existing objects must be tracked in a registry but the object's entry in
+// the registry cannot be removed from the object's dtor due to
+// synchronization issues.  In this case, the registry can be cleaned up
+// later by identifying entries for which RefIfNonZero() returns null.
+struct UnrefNoDelete {
+  template <typename T>
+  void operator()(T* /*p*/) {}
 };
-template <typename T>
-class Delete<T, kUnrefCallDtor> {
- public:
-  explicit Delete(T* t) { t->~T(); }
+
+// Call the object's dtor but do not delete it.  This is useful for cases
+// where the object is stored in memory allocated elsewhere (e.g., the call
+// arena).
+struct UnrefCallDtor {
+  template <typename T>
+  void operator()(T* p) {
+    p->~T();
+  }
 };
-}  // namespace internal
 
 // A base class for reference-counted objects.
 // New objects should be created via new and start with a refcount of 1.
@@ -276,7 +269,7 @@ class Delete<T, kUnrefCallDtor> {
 //    ch->Unref();
 //
 template <typename Child, typename Impl = PolymorphicRefCount,
-          UnrefBehavior UnrefBehaviorArg = kUnrefDelete>
+          typename UnrefBehavior = UnrefDelete>
 class RefCounted : public Impl {
  public:
   using RefCountedChildType = Child;
@@ -301,12 +294,12 @@ class RefCounted : public Impl {
   // friend of this class.
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
+      unref_behavior_(static_cast<Child*>(this));
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
+      unref_behavior_(static_cast<Child*>(this));
     }
   }
 
@@ -331,6 +324,11 @@ class RefCounted : public Impl {
                       intptr_t initial_refcount = 1)
       : refs_(initial_refcount, trace) {}
 
+  // Note: Tracing is a no-op on non-debug builds.
+  explicit RefCounted(UnrefBehavior b, const char* trace = nullptr,
+                      intptr_t initial_refcount = 1)
+      : refs_(initial_refcount, trace), unref_behavior_(b) {}
+
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().
   template <typename T>
@@ -342,6 +340,7 @@ class RefCounted : public Impl {
   }
 
   RefCount refs_;
+  GPR_NO_UNIQUE_ADDRESS UnrefBehavior unref_behavior_;
 };
 
 }  // namespace grpc_core

data/src/core/lib/gprpp/thd.h

@@ -25,6 +25,11 @@
 
 #include <stddef.h>
 
+#include <memory>
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+
 #include <grpc/support/log.h>
 
 namespace grpc_core {
@@ -86,6 +91,17 @@ class Thread {
   Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
          bool* success = nullptr, const Options& options = Options());
 
+  Thread(const char* thd_name, absl::AnyInvocable<void()> fn,
+         bool* success = nullptr, const Options& options = Options())
+      : Thread(
+            thd_name,
+            [](void* p) {
+              std::unique_ptr<absl::AnyInvocable<void()>> fn_from_p(
+                  static_cast<absl::AnyInvocable<void()>*>(p));
+              (*fn_from_p)();
+            },
+            new absl::AnyInvocable<void()>(std::move(fn)), success, options) {}
+
   /// Move constructor for thread. After this is called, the other thread
   /// no longer represents a living thread object
   Thread(Thread&& other) noexcept

data/src/core/lib/gprpp/time.cc

@@ -25,6 +25,7 @@
 
 #include "absl/strings/str_format.h"
 
+#include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/no_destruct.h"

data/src/core/lib/gprpp/time.h

@@ -26,20 +26,20 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gpr/useful.h"
 
-#define GRPC_LOG_EVERY_N_SEC(n, format, ...)                    \
+#define GRPC_LOG_EVERY_N_SEC(n, severity, format, ...)          \
   do {                                                          \
     static std::atomic<uint64_t> prev{0};                       \
     uint64_t now = grpc_core::Timestamp::FromTimespecRoundDown( \
                        gpr_now(GPR_CLOCK_MONOTONIC))            \
                        .milliseconds_after_process_epoch();     \
-    if ((now - prev.exchange(now)) > (n)*1000) {                \
-      gpr_log(GPR_INFO, format, __VA_ARGS__);                   \
+    uint64_t prev_tsamp = prev.exchange(now);                   \
+    if (prev_tsamp == 0 || now - prev_tsamp > (n)*1000) {       \
+      gpr_log(severity, format, __VA_ARGS__);                   \
     }                                                           \
   } while (0)
 

data/src/core/lib/gprpp/{thd_windows.cc → windows/thd.cc}

@@ -146,8 +146,8 @@ class ThreadInternalsWindows
 
 namespace grpc_core {
 
-Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
-               bool* success, const Options& options)
+Thread::Thread(const char* /* thd_name */, void (*thd_body)(void* arg),
+               void* arg, bool* success, const Options& options)
     : options_(options) {
   bool outcome = false;
   impl_ = new ThreadInternalsWindows(thd_body, arg, &outcome, options);

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

@@ -171,8 +171,8 @@ class CallCombinerClosureList {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
       gpr_log(GPR_INFO,
               "CallCombinerClosureList executing closure while already "
-              "holding call_combiner %p: closure=%p error=%s reason=%s",
-              call_combiner, closures_[0].closure,
+              "holding call_combiner %p: closure=%s error=%s reason=%s",
+              call_combiner, closures_[0].closure->DebugString().c_str(),
               StatusToString(closures_[0].error).c_str(), closures_[0].reason);
     }
     // This will release the call combiner.

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

@@ -113,7 +113,8 @@ static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error,
 }
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_read_cb %p %p:%p", ep,
             ep->read_cb, ep->read_cb->cb, ep->read_cb->cb_arg);
     size_t i;
@@ -225,7 +226,8 @@ static void WriteAction(void* arg, grpc_error_handle error) {
       EP_UNREF(ep, "write");
     }
 
-    if (grpc_tcp_trace.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
+        gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
       grpc_slice trace_slice = grpc_slice_sub(slice, 0, write_size);
       char* dump = grpc_dump_slice(trace_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
       gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string.c_str(),

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

@@ -27,26 +27,21 @@
 #include <string.h>
 
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_split.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
 
-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
 
@@ -106,40 +101,14 @@ static const grpc_event_engine_vtable* g_vtables[] = {
     nullptr,
 };
 
-static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
-  size_t n = *ns;
-  size_t np = n + 1;
-  char* s;
-  size_t len;
-  GPR_ASSERT(end >= beg);
-  len = static_cast<size_t>(end - beg);
-  s = static_cast<char*>(gpr_malloc(len + 1));
-  memcpy(s, beg, len);
-  s[len] = 0;
-  *ss = static_cast<char**>(gpr_realloc(*ss, sizeof(char**) * np));
-  (*ss)[n] = s;
-  *ns = np;
-}
-
-static void split(const char* s, char*** ss, size_t* ns) {
-  const char* c = strchr(s, ',');
-  if (c == nullptr) {
-    add(s, s + strlen(s), ss, ns);
-  } else {
-    add(s, c, ss, ns);
-    split(c + 1, ss, ns);
-  }
-}
-
-static bool is(const char* want, const char* have) {
-  return 0 == strcmp(want, "all") || 0 == strcmp(want, have);
+static bool is(absl::string_view want, absl::string_view have) {
+  return want == "all" || want == have;
 }
 
-static void try_engine(const char* engine) {
+static void try_engine(absl::string_view engine) {
   for (size_t i = 0; i < GPR_ARRAY_SIZE(g_vtables); i++) {
     if (g_vtables[i] != nullptr && is(engine, g_vtables[i]->name) &&
-        g_vtables[i]->check_engine_available(
-            0 == strcmp(engine, g_vtables[i]->name))) {
+        g_vtables[i]->check_engine_available(engine == g_vtables[i]->name)) {
       g_event_engine = g_vtables[i];
       gpr_log(GPR_DEBUG, "Using polling engine: %s", g_event_engine->name);
       return;
@@ -173,25 +142,16 @@ const char* grpc_get_poll_strategy_name() { return g_event_engine->name; }
 
 void grpc_event_engine_init(void) {
   gpr_once_init(&g_choose_engine, []() {
-    grpc_core::UniquePtr<char> value =
-        GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
-
-    char** strings = nullptr;
-    size_t nstrings = 0;
-    split(value.get(), &strings, &nstrings);
-
-    for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
-      try_engine(strings[i]);
-    }
-
-    for (size_t i = 0; i < nstrings; i++) {
-      gpr_free(strings[i]);
+    auto value = grpc_core::ConfigVars::Get().PollStrategy();
+    for (auto trial : absl::StrSplit(value, ',')) {
+      try_engine(trial);
+      if (g_event_engine != nullptr) return;
     }
-    gpr_free(strings);
 
     if (g_event_engine == nullptr) {
-      grpc_core::Crash(absl::StrFormat(
-          "No event engine could be initialized from %s", value.get()));
+      grpc_core::Crash(
+          absl::StrFormat("No event engine could be initialized from %s",
+                          std::string(value).c_str()));
     }
   });
   g_event_engine->init_engine();