grpc 1.62.0 → 1.65.1

data/src/core/lib/event_engine/extensions/chaotic_good_extension.h

@@ -0,0 +1,65 @@
+// Copyright 2024 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHAOTIC_GOOD_EXTENSION_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHAOTIC_GOOD_EXTENSION_H
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/resource_quota/memory_quota.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// An Endpoint extension class that will be supported by EventEngine endpoints
+/// which need to work with the ChaoticGood transport.
+class ChaoticGoodExtension {
+ public:
+  virtual ~ChaoticGoodExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.chaotic_good_extension";
+  }
+
+  /// If invoked, the endpoint begins collecting TCP stats. If the boolean
+  /// arg is_control_channel is true, then the collected stats are grouped into
+  /// histograms and counters specific to the chaotic good control channel.
+  /// Otherwise they are grouped into histograms and counters specific to the
+  /// chaotic good data channel.
+  virtual void EnableStatsCollection(bool is_control_channel) = 0;
+
+  /// Forces the endpoint to use the provided memory quota instead of using the
+  /// one provided to it through the channel args. It is safe to call this
+  /// only when there are no outstanding Reads on the Endpoint.
+  virtual void UseMemoryQuota(grpc_core::MemoryQuotaRefPtr mem_quota) = 0;
+
+  /// Forces the endpoint to receive rpcs in one contiguous block of memory.
+  /// It is safe to call this only when there are no outstanding Reads on
+  /// the Endpoint.
+  virtual void EnableRpcReceiveCoalescing() = 0;
+
+  /// Disables rpc receive coalescing until it is explicitly enabled again.
+  /// It is safe to call this only when there are no outstanding Reads on
+  /// the Endpoint.
+  virtual void DisableRpcReceiveCoalescing() = 0;
+  /// If invoked, the endpoint tries to preserve proper order and alignment of
+  /// any memory that maybe shared across reads.
+  virtual void EnforceRxMemoryAlignment() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHAOTIC_GOOD_EXTENSION_H

data/src/core/lib/event_engine/extensions/supports_fd.h

@@ -15,13 +15,12 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_SUPPORTS_FD_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_SUPPORTS_FD_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/functional/any_invocable.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -113,6 +112,13 @@ class EventEngineSupportsFdExtension {
       int fd, const EndpointConfig& config,
       MemoryAllocator memory_allocator) = 0;
 
+  /// Creates an EventEngine::Endpoint from an fd which is already assumed to be
+  /// connected to a remote peer. See \a CreatePosixEndpointFromFd for details.
+  /// This has the same behavior, but the \a memory_allocator is taken from the
+  /// EndpointConfig's resource quota.
+  virtual std::unique_ptr<EventEngine::Endpoint> CreateEndpointFromFd(
+      int fd, const EndpointConfig& config) = 0;
+
   /// Called when the posix listener has accepted a new client connection.
   /// \a listener_fd - The listening socket fd that accepted the new client
   /// connection.

data/src/core/lib/event_engine/extensions/tcp_trace.h

@@ -0,0 +1,43 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_TCP_TRACE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_TCP_TRACE_H
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/telemetry/tcp_tracer.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/** If non-zero, enable TCP tracing and stats collection. */
+#define GRPC_ARG_TCP_TRACING_ENABLED "grpc.tcp_tracing_enabled"
+
+class TcpTraceExtension {
+ public:
+  virtual ~TcpTraceExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.tcp_trace";
+  }
+  virtual std::shared_ptr<grpc_core::TcpTracerInterface>
+  InitializeAndReturnTcpTracer() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_TCP_TRACE_H

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

@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/event_engine/forkable.h"
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
 #include <pthread.h>
@@ -27,12 +28,11 @@
 #include <vector>
 
 #include "src/core/lib/config/config_vars.h"
+#include "src/core/lib/debug/trace.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-grpc_core::TraceFlag grpc_trace_fork(false, "fork");
-
 namespace {
 bool IsForkEnabled() {
   static bool enabled = grpc_core::ConfigVars::Get().EnableForkSupport();
@@ -44,7 +44,7 @@ void ObjectGroupForkHandler::RegisterForkable(
     std::shared_ptr<Forkable> forkable, GRPC_UNUSED void (*prepare)(void),
     GRPC_UNUSED void (*parent)(void), GRPC_UNUSED void (*child)(void)) {
   if (IsForkEnabled()) {
-    GPR_ASSERT(!is_forking_);
+    CHECK(!is_forking_);
     forkables_.emplace_back(forkable);
 #ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
     if (!std::exchange(registered_, true)) {
@@ -56,8 +56,8 @@ void ObjectGroupForkHandler::RegisterForkable(
 
 void ObjectGroupForkHandler::Prefork() {
   if (IsForkEnabled()) {
-    GPR_ASSERT(!std::exchange(is_forking_, true));
-    GRPC_FORK_TRACE_LOG_STRING("PrepareFork");
+    CHECK(!std::exchange(is_forking_, true));
+    GRPC_TRACE_LOG(fork, INFO) << "PrepareFork";
     for (auto it = forkables_.begin(); it != forkables_.end();) {
       auto shared = it->lock();
       if (shared) {
@@ -72,8 +72,8 @@ void ObjectGroupForkHandler::Prefork() {
 
 void ObjectGroupForkHandler::PostforkParent() {
   if (IsForkEnabled()) {
-    GPR_ASSERT(is_forking_);
-    GRPC_FORK_TRACE_LOG_STRING("PostforkParent");
+    CHECK(is_forking_);
+    GRPC_TRACE_LOG(fork, INFO) << "PostforkParent";
     for (auto it = forkables_.begin(); it != forkables_.end();) {
       auto shared = it->lock();
       if (shared) {
@@ -89,8 +89,8 @@ void ObjectGroupForkHandler::PostforkParent() {
 
 void ObjectGroupForkHandler::PostforkChild() {
   if (IsForkEnabled()) {
-    GPR_ASSERT(is_forking_);
-    GRPC_FORK_TRACE_LOG_STRING("PostforkChild");
+    CHECK(is_forking_);
+    GRPC_TRACE_LOG(fork, INFO) << "PostforkChild";
     for (auto it = forkables_.begin(); it != forkables_.end();) {
       auto shared = it->lock();
       if (shared) {

data/src/core/lib/event_engine/forkable.h

@@ -14,29 +14,17 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <vector>
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-extern grpc_core::TraceFlag grpc_trace_fork;
-
-#define GRPC_FORK_TRACE_LOG(format, ...)                 \
-  do {                                                   \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fork)) {      \
-      gpr_log(GPR_DEBUG, "[fork] " format, __VA_ARGS__); \
-    }                                                    \
-  } while (0)
-
-#define GRPC_FORK_TRACE_LOG_STRING(format) GRPC_FORK_TRACE_LOG("%s", format)
-
 // An interface to be implemented by EventEngines that wish to have managed fork
 // support. The child class must guarantee that those methods are thread-safe.
 class Forkable {

data/src/core/lib/event_engine/grpc_polled_fd.h

@@ -15,11 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_GRPC_POLLED_FD_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_GRPC_POLLED_FD_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #if GRPC_ARES == 1
 

data/src/core/lib/event_engine/handle_containers.h

@@ -14,8 +14,6 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <cstdint>
@@ -25,6 +23,7 @@
 #include "absl/hash/hash.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/memory_allocator_factory.h

@@ -13,14 +13,13 @@
 // limitations under the License.
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_MEMORY_ALLOCATOR_FACTORY_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_MEMORY_ALLOCATOR_FACTORY_H
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <utility>
 
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/memory_allocator.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/resource_quota/memory_quota.h"
 

data/src/core/lib/event_engine/poller.h

@@ -14,11 +14,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POLLER_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POLLER_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/functional/function_ref.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/posix.h

@@ -14,20 +14,27 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_H
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/extensions/can_track_errors.h"
+#include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
 #include "src/core/lib/event_engine/extensions/supports_fd.h"
 #include "src/core/lib/event_engine/query_extensions.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
+/// This defines an interface that posix specific EventEngines endpoints
+/// may implement to support additional chaotic good related functionality.
+class PosixEndpointWithChaoticGoodSupport
+    : public ExtendedType<EventEngine::Endpoint, ChaoticGoodExtension,
+                          EndpointSupportsFdExtension,
+                          EndpointCanTrackErrorsExtension> {};
+
 /// This defines an interface that posix specific EventEngines endpoints
 /// may implement to support additional file descriptor related functionality.
 class PosixEndpointWithFdSupport

data/src/core/lib/event_engine/posix_engine/ev_epoll1_linux.cc

@@ -11,8 +11,6 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h"
 
 #include <stdint.h>
@@ -20,13 +18,15 @@
 #include <atomic>
 #include <memory>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/event_engine/poller.h"
@@ -164,14 +164,14 @@ int EpollCreateAndCloexec() {
 #ifdef GRPC_LINUX_EPOLL_CREATE1
   int fd = epoll_create1(EPOLL_CLOEXEC);
   if (fd < 0) {
-    gpr_log(GPR_ERROR, "epoll_create1 unavailable");
+    LOG(ERROR) << "epoll_create1 unavailable";
   }
 #else
   int fd = epoll_create(MAX_EPOLL_EVENTS);
   if (fd < 0) {
-    gpr_log(GPR_ERROR, "epoll_create unavailable");
+    LOG(ERROR) << "epoll_create unavailable";
   } else if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) {
-    gpr_log(GPR_ERROR, "fcntl following epoll_create failed");
+    LOG(ERROR) << "fcntl following epoll_create failed";
     return -1;
   }
 #endif
@@ -297,8 +297,8 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
       epoll_event phony_event;
       if (epoll_ctl(poller_->g_epoll_set_.epfd, EPOLL_CTL_DEL, fd_,
                     &phony_event) != 0) {
-        gpr_log(GPR_ERROR, "OrphanHandle: epoll_ctl failed: %s",
-                grpc_core::StrError(errno).c_str());
+        LOG(ERROR) << "OrphanHandle: epoll_ctl failed: "
+                   << grpc_core::StrError(errno);
       }
     }
     *release_fd = fd_;
@@ -341,8 +341,8 @@ void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
       epoll_event phony_event;
       if (epoll_ctl(poller_->g_epoll_set_.epfd, EPOLL_CTL_DEL, fd_,
                     &phony_event) != 0) {
-        gpr_log(GPR_ERROR, "HandleShutdownInternal: epoll_ctl failed: %s",
-                grpc_core::StrError(errno).c_str());
+        LOG(ERROR) << "HandleShutdownInternal: epoll_ctl failed: "
+                   << grpc_core::StrError(errno);
       }
     }
     write_closure_->SetShutdown(why);
@@ -354,14 +354,15 @@ Epoll1Poller::Epoll1Poller(Scheduler* scheduler)
     : scheduler_(scheduler), was_kicked_(false), closed_(false) {
   g_epoll_set_.epfd = EpollCreateAndCloexec();
   wakeup_fd_ = *CreateWakeupFd();
-  GPR_ASSERT(wakeup_fd_ != nullptr);
-  GPR_ASSERT(g_epoll_set_.epfd >= 0);
-  gpr_log(GPR_INFO, "grpc epoll fd: %d", g_epoll_set_.epfd);
+  CHECK(wakeup_fd_ != nullptr);
+  CHECK_GE(g_epoll_set_.epfd, 0);
+  GRPC_TRACE_LOG(event_engine_poller, INFO)
+      << "grpc epoll fd: " << g_epoll_set_.epfd;
   struct epoll_event ev;
   ev.events = static_cast<uint32_t>(EPOLLIN | EPOLLET);
   ev.data.ptr = wakeup_fd_.get();
-  GPR_ASSERT(epoll_ctl(g_epoll_set_.epfd, EPOLL_CTL_ADD, wakeup_fd_->ReadFd(),
-                       &ev) == 0);
+  CHECK(epoll_ctl(g_epoll_set_.epfd, EPOLL_CTL_ADD, wakeup_fd_->ReadFd(),
+                  &ev) == 0);
   g_epoll_set_.num_events = 0;
   g_epoll_set_.cursor = 0;
   ForkPollerListAddPoller(this);
@@ -414,8 +415,7 @@ EventHandle* Epoll1Poller::CreateHandle(int fd, absl::string_view /*name*/,
   ev.data.ptr = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(new_handle) |
                                         (track_err ? 1 : 0));
   if (epoll_ctl(g_epoll_set_.epfd, EPOLL_CTL_ADD, fd, &ev) != 0) {
-    gpr_log(GPR_ERROR, "epoll_ctl failed: %s",
-            grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "epoll_ctl failed: " << grpc_core::StrError(errno);
   }
 
   return new_handle;
@@ -439,7 +439,7 @@ bool Epoll1Poller::ProcessEpollEvents(int max_epoll_events_to_handle,
     struct epoll_event* ev = &g_epoll_set_.events[c];
     void* data_ptr = ev->data.ptr;
     if (data_ptr == wakeup_fd_.get()) {
-      GPR_ASSERT(wakeup_fd_->ConsumeWakeup().ok());
+      CHECK(wakeup_fd_->ConsumeWakeup().ok());
       was_kicked = true;
     } else {
       Epoll1EventHandle* handle = reinterpret_cast<Epoll1EventHandle*>(
@@ -558,7 +558,7 @@ void Epoll1Poller::Kick() {
     return;
   }
   was_kicked_ = true;
-  GPR_ASSERT(wakeup_fd_->Wakeup().ok());
+  CHECK(wakeup_fd_->Wakeup().ok());
 }
 
 std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(Scheduler* scheduler) {

data/src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h

@@ -14,8 +14,6 @@
 
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H
-#include <grpc/support/port_platform.h>
-
 #include <list>
 #include <memory>
 #include <string>
@@ -26,6 +24,7 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.cc

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/event_engine/posix_engine/ev_poll_posix.h"
 
 #include <stdint.h>
@@ -25,6 +23,7 @@
 
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
@@ -32,6 +31,7 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
@@ -340,7 +340,7 @@ EventHandle* PollPoller::CreateHandle(int fd, absl::string_view /*name*/,
                                       bool track_err) {
   // Avoid unused-parameter warning for debug-only parameter
   (void)track_err;
-  GPR_DEBUG_ASSERT(track_err == false);
+  DCHECK(track_err == false);
   PollEventHandle* handle = new PollEventHandle(fd, shared_from_this());
   ForkFdListAddHandle(handle);
   // We need to send a kick to the thread executing Work(..) so that it can
@@ -360,7 +360,7 @@ void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done, int* release_fd,
     if (release_fd != nullptr) {
       *release_fd = fd_;
     }
-    GPR_ASSERT(!is_orphaned_);
+    CHECK(!is_orphaned_);
     is_orphaned_ = true;
     // Perform shutdown operations if not already done so.
     if (!is_shutdown_) {
@@ -574,7 +574,7 @@ void PollPoller::KickExternal(bool ext) {
   }
   was_kicked_ = true;
   was_kicked_ext_ = ext;
-  GPR_ASSERT(wakeup_fd_->Wakeup().ok());
+  CHECK(wakeup_fd_->Wakeup().ok());
 }
 
 void PollPoller::Kick() { KickExternal(true); }
@@ -613,7 +613,7 @@ PollPoller::PollPoller(Scheduler* scheduler)
       poll_handles_list_head_(nullptr),
       closed_(false) {
   wakeup_fd_ = *CreateWakeupFd();
-  GPR_ASSERT(wakeup_fd_ != nullptr);
+  CHECK(wakeup_fd_ != nullptr);
   ForkPollerListAddPoller(this);
 }
 
@@ -626,15 +626,15 @@ PollPoller::PollPoller(Scheduler* scheduler, bool use_phony_poll)
       poll_handles_list_head_(nullptr),
       closed_(false) {
   wakeup_fd_ = *CreateWakeupFd();
-  GPR_ASSERT(wakeup_fd_ != nullptr);
+  CHECK(wakeup_fd_ != nullptr);
   ForkPollerListAddPoller(this);
 }
 
 PollPoller::~PollPoller() {
   // Assert that no active handles are present at the time of destruction.
   // They should have been orphaned before reaching this state.
-  GPR_ASSERT(num_poll_handles_ == 0);
-  GPR_ASSERT(poll_handles_list_head_ == nullptr);
+  CHECK_EQ(num_poll_handles_, 0);
+  CHECK_EQ(poll_handles_list_head_, nullptr);
 }
 
 Poller::WorkResult PollPoller::Work(
@@ -686,7 +686,7 @@ Poller::WorkResult PollPoller::Work(
         // There shouldn't be any orphaned fds at this point. This is because
         // prior to marking a handle as orphaned it is first removed from
         // poll handle list for the poller under the poller lock.
-        GPR_ASSERT(!head->IsOrphaned());
+        CHECK(!head->IsOrphaned());
         if (!head->IsPollhup()) {
           pfds[pfd_count].fd = head->WrappedFd();
           watchers[pfd_count] = head;
@@ -762,7 +762,7 @@ Poller::WorkResult PollPoller::Work(
       }
     } else {
       if (pfds[0].revents & kPollinCheck) {
-        GPR_ASSERT(wakeup_fd_->ConsumeWakeup().ok());
+        CHECK(wakeup_fd_->ConsumeWakeup().ok());
       }
       for (i = 1; i < pfd_count; i++) {
         PollEventHandle* head = watchers[i];

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.h

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <string>
 
@@ -25,6 +23,7 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"

data/src/core/lib/event_engine/posix_engine/event_poller.h

@@ -14,8 +14,6 @@
 
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/functional/any_invocable.h"
@@ -23,6 +21,7 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/poller.h"

data/src/core/lib/event_engine/posix_engine/event_poller_posix_default.cc

@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <string>
 
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h"

data/src/core/lib/event_engine/posix_engine/event_poller_posix_default.h

@@ -15,10 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_event_engine {
 namespace experimental {
 

data/src/core/lib/event_engine/posix_engine/grpc_polled_fd_posix.h

@@ -15,11 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_GRPC_POLLED_FD_POSIX_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_GRPC_POLLED_FD_POSIX_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/port.h"