grpc 1.41.0 → 1.42.0.pre1

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

@@ -357,7 +357,12 @@ static void unref_by(grpc_fd* fd, int n) {
     gpr_mu_destroy(&fd->mu);
     grpc_iomgr_unregister_object(&fd->iomgr_object);
     fork_fd_list_remove_node(fd->fork_fd_list);
-    if (fd->shutdown) GRPC_ERROR_UNREF(fd->shutdown_error);
+    if (fd->shutdown) {
+      GRPC_ERROR_UNREF(fd->shutdown_error);
+    }
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    fd->shutdown_error.~Status();
+#endif
     gpr_free(fd);
   } else {
     GPR_ASSERT(old > n);
@@ -372,6 +377,9 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   gpr_mu_init(&r->mu);
   gpr_atm_rel_store(&r->refst, 1);
   r->shutdown = 0;
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  new (&r->shutdown_error) absl::Status();
+#endif
   r->read_closure = CLOSURE_NOT_READY;
   r->write_closure = CLOSURE_NOT_READY;
   r->fd = fd;
@@ -405,11 +413,11 @@ static grpc_error_handle pollset_kick_locked(grpc_fd_watcher* watcher) {
 
 static void maybe_wake_one_watcher_locked(grpc_fd* fd) {
   if (fd->inactive_watcher_root.next != &fd->inactive_watcher_root) {
-    pollset_kick_locked(fd->inactive_watcher_root.next);
+    (void)pollset_kick_locked(fd->inactive_watcher_root.next);
   } else if (fd->read_watcher) {
-    pollset_kick_locked(fd->read_watcher);
+    (void)pollset_kick_locked(fd->read_watcher);
   } else if (fd->write_watcher) {
-    pollset_kick_locked(fd->write_watcher);
+    (void)pollset_kick_locked(fd->write_watcher);
   }
 }
 
@@ -417,13 +425,13 @@ static void wake_all_watchers_locked(grpc_fd* fd) {
   grpc_fd_watcher* watcher;
   for (watcher = fd->inactive_watcher_root.next;
        watcher != &fd->inactive_watcher_root; watcher = watcher->next) {
-    pollset_kick_locked(watcher);
+    (void)pollset_kick_locked(watcher);
   }
   if (fd->read_watcher) {
-    pollset_kick_locked(fd->read_watcher);
+    (void)pollset_kick_locked(fd->read_watcher);
   }
   if (fd->write_watcher && fd->write_watcher != fd->read_watcher) {
-    pollset_kick_locked(fd->write_watcher);
+    (void)pollset_kick_locked(fd->write_watcher);
   }
 }
 
@@ -873,13 +881,13 @@ static void pollset_add_fd(grpc_pollset* pollset, grpc_fd* fd) {
   }
   if (pollset->fd_count == pollset->fd_capacity) {
     pollset->fd_capacity =
-        GPR_MAX(pollset->fd_capacity + 8, pollset->fd_count * 3 / 2);
+        std::max(pollset->fd_capacity + 8, pollset->fd_count * 3 / 2);
     pollset->fds = static_cast<grpc_fd**>(
         gpr_realloc(pollset->fds, sizeof(grpc_fd*) * pollset->fd_capacity));
   }
   pollset->fds[pollset->fd_count++] = fd;
   GRPC_FD_REF(fd, "multipoller");
-  pollset_kick(pollset, nullptr);
+  (void)pollset_kick(pollset, nullptr);
 exit:
   gpr_mu_unlock(&pollset->mu);
 }
@@ -1114,7 +1122,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
   /* check shutdown conditions */
   if (pollset->shutting_down) {
     if (pollset_has_workers(pollset)) {
-      pollset_kick(pollset, nullptr);
+      (void)pollset_kick(pollset, nullptr);
     } else if (!pollset->called_shutdown && !pollset_has_observers(pollset)) {
       pollset->called_shutdown = 1;
       gpr_mu_unlock(&pollset->mu);
@@ -1136,7 +1144,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   GPR_ASSERT(!pollset->shutting_down);
   pollset->shutting_down = 1;
   pollset->shutdown_done = closure;
-  pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
+  (void)pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
   if (!pollset->called_shutdown && !pollset_has_observers(pollset)) {
     pollset->called_shutdown = 1;
     finish_shutdown(pollset);
@@ -1198,7 +1206,7 @@ static void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
   gpr_mu_lock(&pollset_set->mu);
   if (pollset_set->pollset_count == pollset_set->pollset_capacity) {
     pollset_set->pollset_capacity =
-        GPR_MAX(8, 2 * pollset_set->pollset_capacity);
+        std::max(size_t(8), 2 * pollset_set->pollset_capacity);
     pollset_set->pollsets = static_cast<grpc_pollset**>(gpr_realloc(
         pollset_set->pollsets,
         pollset_set->pollset_capacity * sizeof(*pollset_set->pollsets)));
@@ -1223,8 +1231,8 @@ static void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
   for (i = 0; i < pollset_set->pollset_count; i++) {
     if (pollset_set->pollsets[i] == pollset) {
       pollset_set->pollset_count--;
-      GPR_SWAP(grpc_pollset*, pollset_set->pollsets[i],
-               pollset_set->pollsets[pollset_set->pollset_count]);
+      std::swap(pollset_set->pollsets[i],
+                pollset_set->pollsets[pollset_set->pollset_count]);
       break;
     }
   }
@@ -1247,7 +1255,8 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* bag,
   size_t i, j;
   gpr_mu_lock(&bag->mu);
   if (bag->pollset_set_count == bag->pollset_set_capacity) {
-    bag->pollset_set_capacity = GPR_MAX(8, 2 * bag->pollset_set_capacity);
+    bag->pollset_set_capacity =
+        std::max(size_t(8), 2 * bag->pollset_set_capacity);
     bag->pollset_sets = static_cast<grpc_pollset_set**>(
         gpr_realloc(bag->pollset_sets,
                     bag->pollset_set_capacity * sizeof(*bag->pollset_sets)));
@@ -1272,8 +1281,8 @@ static void pollset_set_del_pollset_set(grpc_pollset_set* bag,
   for (i = 0; i < bag->pollset_set_count; i++) {
     if (bag->pollset_sets[i] == item) {
       bag->pollset_set_count--;
-      GPR_SWAP(grpc_pollset_set*, bag->pollset_sets[i],
-               bag->pollset_sets[bag->pollset_set_count]);
+      std::swap(bag->pollset_sets[i],
+                bag->pollset_sets[bag->pollset_set_count]);
       break;
     }
   }
@@ -1284,7 +1293,8 @@ static void pollset_set_add_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
   size_t i;
   gpr_mu_lock(&pollset_set->mu);
   if (pollset_set->fd_count == pollset_set->fd_capacity) {
-    pollset_set->fd_capacity = GPR_MAX(8, 2 * pollset_set->fd_capacity);
+    pollset_set->fd_capacity =
+        std::max(size_t(8), 2 * pollset_set->fd_capacity);
     pollset_set->fds = static_cast<grpc_fd**>(
         gpr_realloc(pollset_set->fds,
                     pollset_set->fd_capacity * sizeof(*pollset_set->fds)));
@@ -1306,8 +1316,7 @@ static void pollset_set_del_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
   for (i = 0; i < pollset_set->fd_count; i++) {
     if (pollset_set->fds[i] == fd) {
       pollset_set->fd_count--;
-      GPR_SWAP(grpc_fd*, pollset_set->fds[i],
-               pollset_set->fds[pollset_set->fd_count]);
+      std::swap(pollset_set->fds[i], pollset_set->fds[pollset_set->fd_count]);
       GRPC_FD_UNREF(fd, "pollset_set");
       break;
     }

data/src/core/lib/iomgr/event_engine/closure.cc

@@ -17,38 +17,61 @@
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/event_engine/closure.h"
 #include "src/core/lib/iomgr/event_engine/pollset.h"
 #include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-EventEngine::Callback GrpcClosureToCallback(grpc_closure* closure,
-                                            grpc_error_handle error) {
-  return [closure, error](absl::Status status) {
-    grpc_error_handle new_error =
-        grpc_error_add_child(error, absl_status_to_grpc_error(status));
+namespace {
+
+void RunClosure(grpc_closure* closure, grpc_error_handle error) {
+  GPR_ASSERT(closure != nullptr);
 #ifndef NDEBUG
-    closure->scheduled = false;
-    if (grpc_trace_closure.enabled()) {
-      gpr_log(GPR_DEBUG,
-              "EventEngine: running closure %p: created [%s:%d]: %s [%s:%d]",
-              closure, closure->file_created, closure->line_created,
-              closure->run ? "run" : "scheduled", closure->file_initiated,
-              closure->line_initiated);
-    }
+  closure->scheduled = false;
+  if (grpc_trace_closure.enabled()) {
+    gpr_log(GPR_DEBUG,
+            "EventEngine: running closure %p: created [%s:%d]: %s [%s:%d]",
+            closure, closure->file_created, closure->line_created,
+            closure->run ? "run" : "scheduled", closure->file_initiated,
+            closure->line_initiated);
+  }
 #endif
-    closure->cb(closure->cb_arg, new_error);
+  closure->cb(closure->cb_arg, error);
 #ifndef NDEBUG
-    if (grpc_trace_closure.enabled()) {
-      gpr_log(GPR_DEBUG, "EventEngine: closure %p finished", closure);
-    }
+  if (grpc_trace_closure.enabled()) {
+    gpr_log(GPR_DEBUG, "EventEngine: closure %p finished", closure);
+  }
 #endif
-    GRPC_ERROR_UNREF(error);
+}
+
+}  // namespace
+
+std::function<void(absl::Status)> GrpcClosureToStatusCallback(
+    grpc_closure* closure) {
+  return [closure](absl::Status status) {
+    RunClosure(closure, absl_status_to_grpc_error(status));
+    grpc_pollset_ee_broadcast_event();
+  };
+}
+
+std::function<void()> GrpcClosureToCallback(grpc_closure* closure) {
+  return [closure]() {
+    RunClosure(closure, GRPC_ERROR_NONE);
+    grpc_pollset_ee_broadcast_event();
+  };
+}
+
+std::function<void()> GrpcClosureToCallback(grpc_closure* closure,
+                                            grpc_error_handle error) {
+  return [closure, error]() {
+    RunClosure(closure, error);
     grpc_pollset_ee_broadcast_event();
   };
 }
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
+
 #endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/event_engine/closure.h

@@ -24,7 +24,16 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-EventEngine::Callback GrpcClosureToCallback(grpc_closure* closure,
+/// Creates a callback that takes an error status argument.
+std::function<void(absl::Status)> GrpcClosureToStatusCallback(
+    grpc_closure* closure);
+
+/// Create a callback that *does not* take an error status argument.
+std::function<void()> GrpcClosureToCallback(grpc_closure* closure);
+
+/// Creates a callback that *does not* take an error status argument.
+/// This version has a pre-bound error.
+std::function<void()> GrpcClosureToCallback(grpc_closure* closure,
                                             grpc_error_handle error);
 
 }  // namespace experimental

data/src/core/lib/iomgr/event_engine/endpoint.cc

@@ -96,12 +96,12 @@ void endpoint_delete_from_pollset_set(grpc_endpoint* /* ep */,
 /// and will return some kind of sane default (empty strings, nullptrs, etc). It
 /// is the caller's responsibility to ensure that calls to endpoint_shutdown are
 /// synchronized.
-void endpoint_shutdown(grpc_endpoint* ep, grpc_error* why) {
+void endpoint_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
   auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    const char* str = grpc_error_string(why);
+    std::string str = grpc_error_std_string(why);
     gpr_log(GPR_INFO, "TCP Endpoint %p shutdown why=%s", eeep->endpoint.get(),
-            str);
+            str.c_str());
   }
   eeep->endpoint.reset();
 }

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

@@ -60,7 +60,7 @@ bool iomgr_platform_is_any_background_poller_thread(void) {
 }
 
 bool iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* /* closure */, grpc_error* /* error */) {
+    grpc_closure* /* closure */, grpc_error_handle /* error */) {
   return false;
 }
 

data/src/core/lib/iomgr/event_engine/pollset.cc

@@ -40,15 +40,16 @@ void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
 }
 void pollset_destroy(grpc_pollset* pollset) {}
-grpc_error* pollset_work(grpc_pollset* pollset, grpc_pollset_worker** worker,
-                         grpc_millis deadline) {
+grpc_error_handle pollset_work(grpc_pollset* pollset,
+                               grpc_pollset_worker** worker,
+                               grpc_millis deadline) {
   (void)worker;
   gpr_cv_wait(&g_cv, &g_mu,
               grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME));
   return GRPC_ERROR_NONE;
 }
-grpc_error* pollset_kick(grpc_pollset* pollset,
-                         grpc_pollset_worker* specific_worker) {
+grpc_error_handle pollset_kick(grpc_pollset* pollset,
+                               grpc_pollset_worker* specific_worker) {
   (void)pollset;
   (void)specific_worker;
   return GRPC_ERROR_NONE;

data/src/core/lib/iomgr/event_engine/resolver.cc

@@ -79,13 +79,15 @@ void resolve_address(const char* addr, const char* default_port,
                      grpc_pollset_set* /* interested_parties */,
                      grpc_closure* on_done,
                      grpc_resolved_addresses** addresses) {
-  auto dns_resolver = grpc_iomgr_event_engine()->GetDNSResolver();
-  if (!dns_resolver.ok()) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done,
-                            absl_status_to_grpc_error(dns_resolver.status()));
+  std::unique_ptr<EventEngine::DNSResolver> dns_resolver =
+      grpc_iomgr_event_engine()->GetDNSResolver();
+  if (dns_resolver == nullptr) {
+    grpc_core::ExecCtx::Run(
+        DEBUG_LOCATION, on_done,
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to get DNS Resolver."));
     return;
   }
-  new DnsRequest(std::move(*dns_resolver), addr, default_port, on_done,
+  new DnsRequest(std::move(dns_resolver), addr, default_port, on_done,
                  addresses);
 }
 
@@ -93,8 +95,9 @@ void blocking_handle_async_resolve_done(void* arg, grpc_error_handle error) {
   static_cast<Promise<grpc_error_handle>*>(arg)->Set(std::move(error));
 }
 
-grpc_error* blocking_resolve_address(const char* name, const char* default_port,
-                                     grpc_resolved_addresses** addresses) {
+grpc_error_handle blocking_resolve_address(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) {
   grpc_closure on_done;
   Promise<grpc_error_handle> evt;
   GRPC_CLOSURE_INIT(&on_done, blocking_handle_async_resolve_done, &evt,

data/src/core/lib/iomgr/event_engine/tcp.cc

@@ -35,7 +35,7 @@ extern grpc_core::TraceFlag grpc_tcp_trace;
 namespace {
 using ::grpc_event_engine::experimental::ChannelArgsEndpointConfig;
 using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::GrpcClosureToCallback;
+using ::grpc_event_engine::experimental::GrpcClosureToStatusCallback;
 using ::grpc_event_engine::experimental::SliceAllocator;
 using ::grpc_event_engine::experimental::SliceAllocatorFactory;
 using ::grpc_event_engine::experimental::SliceBuffer;
@@ -164,7 +164,7 @@ void tcp_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
   }
 }
 
-grpc_error* tcp_server_create(
+grpc_error_handle tcp_server_create(
     grpc_closure* shutdown_complete, const grpc_channel_args* args,
     grpc_slice_allocator_factory* slice_allocator_factory,
     grpc_tcp_server** server) {
@@ -175,7 +175,8 @@ grpc_error* tcp_server_create(
   EventEngine* event_engine = grpc_iomgr_event_engine();
   absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener =
       event_engine->CreateListener(
-          [server](std::unique_ptr<EventEngine::Endpoint> ee_endpoint) {
+          [server](std::unique_ptr<EventEngine::Endpoint> ee_endpoint,
+                   const SliceAllocator& /*slice_allocator*/) {
             grpc_core::ExecCtx exec_ctx;
             GPR_ASSERT((*server)->on_accept_internal != nullptr);
             grpc_event_engine_endpoint* iomgr_endpoint =
@@ -191,8 +192,8 @@ grpc_error* tcp_server_create(
             exec_ctx.Flush();
             grpc_pollset_ee_broadcast_event();
           },
-          GrpcClosureToCallback(shutdown_complete, GRPC_ERROR_NONE),
-          endpoint_config, std::move(ee_slice_allocator_factory));
+          GrpcClosureToStatusCallback(shutdown_complete), endpoint_config,
+          std::move(ee_slice_allocator_factory));
   if (!listener.ok()) {
     return absl_status_to_grpc_error(listener.status());
   }
@@ -210,9 +211,9 @@ void tcp_server_start(grpc_tcp_server* server,
   GPR_ASSERT(server->listener->Start().ok());
 }
 
-grpc_error* tcp_server_add_port(grpc_tcp_server* s,
-                                const grpc_resolved_address* addr,
-                                int* out_port) {
+grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
+                                      const grpc_resolved_address* addr,
+                                      int* out_port) {
   EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
                                   addr->len);
   auto port = s->listener->Bind(ra);

data/src/core/lib/iomgr/event_engine/timer.cc

@@ -19,6 +19,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/event_engine/closure.h"
 #include "src/core/lib/iomgr/event_engine/iomgr.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/surface/init.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -32,12 +33,16 @@ void timer_init(grpc_timer* timer, grpc_millis deadline,
   timer->ee_task_handle = grpc_iomgr_event_engine()->RunAt(
       grpc_core::ToAbslTime(
           grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME)),
-      GrpcClosureToCallback(closure, GRPC_ERROR_NONE), {});
+      GrpcClosureToCallback(closure));
+  timer->closure = closure;
 }
 
 void timer_cancel(grpc_timer* timer) {
   auto handle = timer->ee_task_handle;
-  grpc_iomgr_event_engine()->TryCancel(handle);
+  if (!grpc_iomgr_event_engine()->Cancel(handle)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, timer->closure,
+                            GRPC_ERROR_CANCELLED);
+  }
 }
 
 /* Internal API */

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

@@ -20,14 +20,11 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/combiner.h"
-#include "src/core/lib/iomgr/event_engine/closure.h"
-#include "src/core/lib/iomgr/event_engine/iomgr.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/profiling/timers.h"
 
 static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
@@ -50,13 +47,8 @@ static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
 }
 
 static void exec_ctx_sched(grpc_closure* closure, grpc_error_handle error) {
-#if defined(GRPC_USE_EVENT_ENGINE) && \
-    defined(GRPC_EVENT_ENGINE_REPLACE_EXEC_CTX)
-  grpc_iomgr_event_engine()->Run(GrpcClosureToCallback(closure, error), {});
-#else
   grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure,
                            error);
-#endif
 }
 
 static gpr_timespec g_start_time;

data/src/core/lib/iomgr/executor/mpmcqueue.cc

@@ -67,7 +67,7 @@ inline void* InfLenFIFOQueue::PopFront() {
 
 InfLenFIFOQueue::Node* InfLenFIFOQueue::AllocateNodes(int num) {
   num_nodes_ = num_nodes_ + num;
-  Node* new_chunk = static_cast<Node*>(gpr_zalloc(sizeof(Node) * num));
+  Node* new_chunk = new Node[num];
   new_chunk[0].next = &new_chunk[1];
   new_chunk[num - 1].prev = &new_chunk[num - 2];
   for (int i = 1; i < num - 1; ++i) {
@@ -79,8 +79,7 @@ InfLenFIFOQueue::Node* InfLenFIFOQueue::AllocateNodes(int num) {
 
 InfLenFIFOQueue::InfLenFIFOQueue() {
   delete_list_size_ = kDeleteListInitSize;
-  delete_list_ =
-      static_cast<Node**>(gpr_zalloc(sizeof(Node*) * delete_list_size_));
+  delete_list_ = new Node*[delete_list_size_];
 
   Node* new_chunk = AllocateNodes(kQueueInitNumNodes);
   delete_list_[delete_list_count_++] = new_chunk;
@@ -95,9 +94,9 @@ InfLenFIFOQueue::InfLenFIFOQueue() {
 InfLenFIFOQueue::~InfLenFIFOQueue() {
   GPR_ASSERT(count_.load(std::memory_order_relaxed) == 0);
   for (size_t i = 0; i < delete_list_count_; ++i) {
-    gpr_free(delete_list_[i]);
+    delete[] delete_list_[i];
   }
-  gpr_free(delete_list_);
+  delete[] delete_list_;
 }
 
 void InfLenFIFOQueue::Put(void* elem) {
@@ -112,8 +111,7 @@ void InfLenFIFOQueue::Put(void* elem) {
     // Expands delete list on full.
     if (delete_list_count_ == delete_list_size_) {
       delete_list_size_ = delete_list_size_ * 2;
-      delete_list_ = static_cast<Node**>(
-          gpr_realloc(delete_list_, sizeof(Node*) * delete_list_size_));
+      delete_list_ = new Node*[delete_list_size_];
     }
     new_chunk[0].prev = queue_tail_->prev;
     new_chunk[curr_count - 1].next = queue_head_;

data/src/core/lib/iomgr/executor/mpmcqueue.h

@@ -74,15 +74,10 @@ class InfLenFIFOQueue : public MPMCQueueInterface {
   int count() const override { return count_.load(std::memory_order_relaxed); }
 
   struct Node {
-    Node* next;  // Linking
-    Node* prev;
-    void* content;             // Points to actual element
+    Node* next = nullptr;  // Linking
+    Node* prev = nullptr;
+    void* content = nullptr;   // Points to actual element
     gpr_timespec insert_time;  // Time for stats
-
-    Node() {
-      next = prev = nullptr;
-      content = nullptr;
-    }
   };
 
   // For test purpose only. Returns number of nodes allocated in queue.

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

@@ -27,12 +27,11 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/iomgr/iomgr_internal.h"
 
 #define MAX_DEPTH 2
 
@@ -92,7 +91,7 @@ TraceFlag executor_trace(false, "executor");
 Executor::Executor(const char* name) : name_(name) {
   adding_thread_lock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
   gpr_atm_rel_store(&num_threads_, 0);
-  max_threads_ = GPR_MAX(1, 2 * gpr_cpu_num_cores());
+  max_threads_ = std::max(1u, 2 * gpr_cpu_num_cores());
 }
 
 void Executor::Init() { SetThreading(true); }
@@ -204,7 +203,7 @@ void Executor::SetThreading(bool threading) {
     // an application.
     // TODO(guantaol): create another method to finish all the pending closures
     // registered in the background poller by grpc_core::Executor.
-    grpc_iomgr_shutdown_background_closure();
+    grpc_iomgr_platform_shutdown_background_closure();
   }
 
   EXECUTOR_TRACE("(%s) SetThreading(%d) done", name_, threading);
@@ -237,7 +236,6 @@ void Executor::ThreadMain(void* arg) {
       break;
     }
 
-    GRPC_STATS_INC_EXECUTOR_QUEUE_DRAINED();
     grpc_closure_list closures = ts->elems;
     ts->elems = GRPC_CLOSURE_LIST_INIT;
     gpr_mu_unlock(&ts->mu);
@@ -254,11 +252,6 @@ void Executor::ThreadMain(void* arg) {
 void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
                        bool is_short) {
   bool retry_push;
-  if (is_short) {
-    GRPC_STATS_INC_EXECUTOR_SCHEDULED_SHORT_ITEMS();
-  } else {
-    GRPC_STATS_INC_EXECUTOR_SCHEDULED_LONG_ITEMS();
-  }
 
   do {
     retry_push = false;
@@ -279,16 +272,14 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
       return;
     }
 
-    if (grpc_iomgr_add_closure_to_background_poller(closure, error)) {
+    if (grpc_iomgr_platform_add_closure_to_background_poller(closure, error)) {
       return;
     }
 
     ThreadState* ts = g_this_thread_state;
     if (ts == nullptr) {
-      ts = &thd_state_[GPR_HASH_POINTER(grpc_core::ExecCtx::Get(),
-                                        cur_thread_count)];
-    } else {
-      GRPC_STATS_INC_EXECUTOR_SCHEDULED_TO_SELF();
+      ts = &thd_state_[grpc_core::HashPointer(grpc_core::ExecCtx::Get(),
+                                              cur_thread_count)];
     }
 
     ThreadState* orig_ts = ts;
@@ -341,7 +332,6 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
       // - Note that gpr_cv_signal() won't immediately wakeup the thread. That
       //   happens after we release the mutex &ts->mu a few lines below
       if (grpc_closure_list_empty(ts->elems) && !ts->shutdown) {
-        GRPC_STATS_INC_EXECUTOR_WAKEUP_INITIATED();
         gpr_cv_signal(&ts->cv);
       }
 
@@ -372,10 +362,6 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
       }
       gpr_spinlock_unlock(&adding_thread_lock_);
     }
-
-    if (retry_push) {
-      GRPC_STATS_INC_EXECUTOR_PUSH_RETRIES();
-    }
   } while (retry_push);
 }
 

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

@@ -53,7 +53,9 @@ static bool g_grpc_abort_on_leaks;
 
 void grpc_iomgr_init() {
   grpc_core::ExecCtx exec_ctx;
-  grpc_determine_iomgr_platform();
+  if (!grpc_have_determined_iomgr_platform()) {
+    grpc_set_default_iomgr_platform();
+  }
   g_shutdown = 0;
   gpr_mu_init(&g_mu);
   gpr_cv_init(&g_rcv);

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

@@ -22,19 +22,14 @@
 
 #include <stddef.h>
 
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/iomgr/timer_manager.h"
-
 static grpc_iomgr_platform_vtable* iomgr_platform_vtable = nullptr;
 
-void grpc_set_iomgr_platform_vtable(grpc_iomgr_platform_vtable* vtable) {
-  iomgr_platform_vtable = vtable;
+bool grpc_have_determined_iomgr_platform() {
+  return iomgr_platform_vtable != nullptr;
 }
 
-void grpc_determine_iomgr_platform() {
-  if (iomgr_platform_vtable == nullptr) {
-    grpc_set_default_iomgr_platform();
-  }
+void grpc_set_iomgr_platform_vtable(grpc_iomgr_platform_vtable* vtable) {
+  iomgr_platform_vtable = vtable;
 }
 
 void grpc_iomgr_platform_init() { iomgr_platform_vtable->init(); }

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

@@ -23,7 +23,8 @@
 
 #include <stdbool.h>
 
-#include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
 
 typedef struct grpc_iomgr_object {
   char* name;
@@ -44,7 +45,7 @@ typedef struct grpc_iomgr_platform_vtable {
 void grpc_iomgr_register_object(grpc_iomgr_object* obj, const char* name);
 void grpc_iomgr_unregister_object(grpc_iomgr_object* obj);
 
-void grpc_determine_iomgr_platform();
+bool grpc_have_determined_iomgr_platform();
 
 void grpc_set_iomgr_platform_vtable(grpc_iomgr_platform_vtable* vtable);
 

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

@@ -71,8 +71,8 @@ end:
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),
                            GRPC_ERROR_STR_FILENAME,
-                           grpc_slice_from_copied_string(
-                               filename));  // TODO(ncteisen), always static?
+
+                           filename);
     GRPC_ERROR_UNREF(error);
     error = error_out;
   }