grpc 1.62.0 → 1.64.0

data/src/core/lib/debug/stats_data.h

@@ -17,8 +17,6 @@
 #ifndef GRPC_SRC_CORE_LIB_DEBUG_STATS_DATA_H
 #define GRPC_SRC_CORE_LIB_DEBUG_STATS_DATA_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <atomic>
@@ -26,6 +24,8 @@
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/debug/histogram_view.h"
 #include "src/core/lib/gprpp/per_cpu.h"
 
@@ -76,6 +76,29 @@ class HistogramCollector_65536_26 {
  private:
   std::atomic<uint64_t> buckets_[26]{};
 };
+class HistogramCollector_100_20;
+class Histogram_100_20 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  friend Histogram_100_20 operator-(const Histogram_100_20& left,
+                                    const Histogram_100_20& right);
+
+ private:
+  friend class HistogramCollector_100_20;
+  uint64_t buckets_[20]{};
+};
+class HistogramCollector_100_20 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_100_20::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_100_20* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[20]{};
+};
 class HistogramCollector_16777216_20;
 class Histogram_16777216_20 {
  public:
@@ -168,6 +191,17 @@ struct GlobalStats {
     kWrrUpdates,
     kWorkSerializerItemsEnqueued,
     kWorkSerializerItemsDequeued,
+    kEconnabortedCount,
+    kEconnresetCount,
+    kEpipeCount,
+    kEtimedoutCount,
+    kEconnrefusedCount,
+    kEnetunreachCount,
+    kEnomsgCount,
+    kEnotconnCount,
+    kEnobufsCount,
+    kUncommonIoErrorCount,
+    kMsgErrqueueErrorCount,
     COUNT
   };
   enum class Histogram {
@@ -185,6 +219,20 @@ struct GlobalStats {
     kWorkSerializerWorkTimeMs,
     kWorkSerializerWorkTimePerItemMs,
     kWorkSerializerItemsPerRun,
+    kChaoticGoodSendmsgsPerWriteControl,
+    kChaoticGoodRecvmsgsPerReadControl,
+    kChaoticGoodSendmsgsPerWriteData,
+    kChaoticGoodRecvmsgsPerReadData,
+    kChaoticGoodThreadHopsPerWriteControl,
+    kChaoticGoodThreadHopsPerReadControl,
+    kChaoticGoodThreadHopsPerWriteData,
+    kChaoticGoodThreadHopsPerReadData,
+    kChaoticGoodTcpReadSizeData,
+    kChaoticGoodTcpReadSizeControl,
+    kChaoticGoodTcpReadOfferData,
+    kChaoticGoodTcpReadOfferControl,
+    kChaoticGoodTcpWriteSizeData,
+    kChaoticGoodTcpWriteSizeControl,
     COUNT
   };
   GlobalStats();
@@ -217,6 +265,17 @@ struct GlobalStats {
       uint64_t wrr_updates;
       uint64_t work_serializer_items_enqueued;
       uint64_t work_serializer_items_dequeued;
+      uint64_t econnaborted_count;
+      uint64_t econnreset_count;
+      uint64_t epipe_count;
+      uint64_t etimedout_count;
+      uint64_t econnrefused_count;
+      uint64_t enetunreach_count;
+      uint64_t enomsg_count;
+      uint64_t enotconn_count;
+      uint64_t enobufs_count;
+      uint64_t uncommon_io_error_count;
+      uint64_t msg_errqueue_error_count;
     };
     uint64_t counters[static_cast<int>(Counter::COUNT)];
   };
@@ -234,6 +293,20 @@ struct GlobalStats {
   Histogram_100000_20 work_serializer_work_time_ms;
   Histogram_100000_20 work_serializer_work_time_per_item_ms;
   Histogram_10000_20 work_serializer_items_per_run;
+  Histogram_100_20 chaotic_good_sendmsgs_per_write_control;
+  Histogram_100_20 chaotic_good_recvmsgs_per_read_control;
+  Histogram_100_20 chaotic_good_sendmsgs_per_write_data;
+  Histogram_100_20 chaotic_good_recvmsgs_per_read_data;
+  Histogram_100_20 chaotic_good_thread_hops_per_write_control;
+  Histogram_100_20 chaotic_good_thread_hops_per_read_control;
+  Histogram_100_20 chaotic_good_thread_hops_per_write_data;
+  Histogram_100_20 chaotic_good_thread_hops_per_read_data;
+  Histogram_16777216_20 chaotic_good_tcp_read_size_data;
+  Histogram_16777216_20 chaotic_good_tcp_read_size_control;
+  Histogram_16777216_20 chaotic_good_tcp_read_offer_data;
+  Histogram_16777216_20 chaotic_good_tcp_read_offer_control;
+  Histogram_16777216_20 chaotic_good_tcp_write_size_data;
+  Histogram_16777216_20 chaotic_good_tcp_write_size_control;
   HistogramView histogram(Histogram which) const;
   std::unique_ptr<GlobalStats> Diff(const GlobalStats& other) const;
 };
@@ -315,6 +388,41 @@ class GlobalStatsCollector {
     data_.this_cpu().work_serializer_items_dequeued.fetch_add(
         1, std::memory_order_relaxed);
   }
+  void IncrementEconnabortedCount() {
+    data_.this_cpu().econnaborted_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEconnresetCount() {
+    data_.this_cpu().econnreset_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEpipeCount() {
+    data_.this_cpu().epipe_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEtimedoutCount() {
+    data_.this_cpu().etimedout_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEconnrefusedCount() {
+    data_.this_cpu().econnrefused_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEnetunreachCount() {
+    data_.this_cpu().enetunreach_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEnomsgCount() {
+    data_.this_cpu().enomsg_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEnotconnCount() {
+    data_.this_cpu().enotconn_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEnobufsCount() {
+    data_.this_cpu().enobufs_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementUncommonIoErrorCount() {
+    data_.this_cpu().uncommon_io_error_count.fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void IncrementMsgErrqueueErrorCount() {
+    data_.this_cpu().msg_errqueue_error_count.fetch_add(
+        1, std::memory_order_relaxed);
+  }
   void IncrementCallInitialSize(int value) {
     data_.this_cpu().call_initial_size.Increment(value);
   }
@@ -357,6 +465,49 @@ class GlobalStatsCollector {
   void IncrementWorkSerializerItemsPerRun(int value) {
     data_.this_cpu().work_serializer_items_per_run.Increment(value);
   }
+  void IncrementChaoticGoodSendmsgsPerWriteControl(int value) {
+    data_.this_cpu().chaotic_good_sendmsgs_per_write_control.Increment(value);
+  }
+  void IncrementChaoticGoodRecvmsgsPerReadControl(int value) {
+    data_.this_cpu().chaotic_good_recvmsgs_per_read_control.Increment(value);
+  }
+  void IncrementChaoticGoodSendmsgsPerWriteData(int value) {
+    data_.this_cpu().chaotic_good_sendmsgs_per_write_data.Increment(value);
+  }
+  void IncrementChaoticGoodRecvmsgsPerReadData(int value) {
+    data_.this_cpu().chaotic_good_recvmsgs_per_read_data.Increment(value);
+  }
+  void IncrementChaoticGoodThreadHopsPerWriteControl(int value) {
+    data_.this_cpu().chaotic_good_thread_hops_per_write_control.Increment(
+        value);
+  }
+  void IncrementChaoticGoodThreadHopsPerReadControl(int value) {
+    data_.this_cpu().chaotic_good_thread_hops_per_read_control.Increment(value);
+  }
+  void IncrementChaoticGoodThreadHopsPerWriteData(int value) {
+    data_.this_cpu().chaotic_good_thread_hops_per_write_data.Increment(value);
+  }
+  void IncrementChaoticGoodThreadHopsPerReadData(int value) {
+    data_.this_cpu().chaotic_good_thread_hops_per_read_data.Increment(value);
+  }
+  void IncrementChaoticGoodTcpReadSizeData(int value) {
+    data_.this_cpu().chaotic_good_tcp_read_size_data.Increment(value);
+  }
+  void IncrementChaoticGoodTcpReadSizeControl(int value) {
+    data_.this_cpu().chaotic_good_tcp_read_size_control.Increment(value);
+  }
+  void IncrementChaoticGoodTcpReadOfferData(int value) {
+    data_.this_cpu().chaotic_good_tcp_read_offer_data.Increment(value);
+  }
+  void IncrementChaoticGoodTcpReadOfferControl(int value) {
+    data_.this_cpu().chaotic_good_tcp_read_offer_control.Increment(value);
+  }
+  void IncrementChaoticGoodTcpWriteSizeData(int value) {
+    data_.this_cpu().chaotic_good_tcp_write_size_data.Increment(value);
+  }
+  void IncrementChaoticGoodTcpWriteSizeControl(int value) {
+    data_.this_cpu().chaotic_good_tcp_write_size_control.Increment(value);
+  }
 
  private:
   struct Data {
@@ -381,6 +532,17 @@ class GlobalStatsCollector {
     std::atomic<uint64_t> wrr_updates{0};
     std::atomic<uint64_t> work_serializer_items_enqueued{0};
     std::atomic<uint64_t> work_serializer_items_dequeued{0};
+    std::atomic<uint64_t> econnaborted_count{0};
+    std::atomic<uint64_t> econnreset_count{0};
+    std::atomic<uint64_t> epipe_count{0};
+    std::atomic<uint64_t> etimedout_count{0};
+    std::atomic<uint64_t> econnrefused_count{0};
+    std::atomic<uint64_t> enetunreach_count{0};
+    std::atomic<uint64_t> enomsg_count{0};
+    std::atomic<uint64_t> enotconn_count{0};
+    std::atomic<uint64_t> enobufs_count{0};
+    std::atomic<uint64_t> uncommon_io_error_count{0};
+    std::atomic<uint64_t> msg_errqueue_error_count{0};
     HistogramCollector_65536_26 call_initial_size;
     HistogramCollector_16777216_20 tcp_write_size;
     HistogramCollector_80_10 tcp_write_iov_size;
@@ -395,6 +557,20 @@ class GlobalStatsCollector {
     HistogramCollector_100000_20 work_serializer_work_time_ms;
     HistogramCollector_100000_20 work_serializer_work_time_per_item_ms;
     HistogramCollector_10000_20 work_serializer_items_per_run;
+    HistogramCollector_100_20 chaotic_good_sendmsgs_per_write_control;
+    HistogramCollector_100_20 chaotic_good_recvmsgs_per_read_control;
+    HistogramCollector_100_20 chaotic_good_sendmsgs_per_write_data;
+    HistogramCollector_100_20 chaotic_good_recvmsgs_per_read_data;
+    HistogramCollector_100_20 chaotic_good_thread_hops_per_write_control;
+    HistogramCollector_100_20 chaotic_good_thread_hops_per_read_control;
+    HistogramCollector_100_20 chaotic_good_thread_hops_per_write_data;
+    HistogramCollector_100_20 chaotic_good_thread_hops_per_read_data;
+    HistogramCollector_16777216_20 chaotic_good_tcp_read_size_data;
+    HistogramCollector_16777216_20 chaotic_good_tcp_read_size_control;
+    HistogramCollector_16777216_20 chaotic_good_tcp_read_offer_data;
+    HistogramCollector_16777216_20 chaotic_good_tcp_read_offer_control;
+    HistogramCollector_16777216_20 chaotic_good_tcp_write_size_data;
+    HistogramCollector_16777216_20 chaotic_good_tcp_write_size_control;
   };
   PerCpu<Data> data_{PerCpuOptions().SetCpusPerShard(4).SetMaxShards(32)};
 };

data/src/core/lib/debug/trace.cc

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/debug/trace.h"
 
 #include <string>
@@ -30,6 +28,7 @@
 
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/config_vars.h"
 

data/src/core/lib/debug/trace.h

@@ -19,14 +19,14 @@
 #ifndef GRPC_SRC_CORE_LIB_DEBUG_TRACE_H
 #define GRPC_SRC_CORE_LIB_DEBUG_TRACE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 #include <map>
 #include <string>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 void grpc_tracer_init();
 void grpc_tracer_shutdown(void);
 

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

@@ -11,13 +11,13 @@
 // 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/ares_resolver.h"
 
 #include <string>
 #include <vector>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 // IWYU pragma: no_include <ares_version.h>
@@ -52,6 +52,7 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
+#include "absl/log/check.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -229,8 +230,8 @@ AresResolver::AresResolver(
 }
 
 AresResolver::~AresResolver() {
-  GPR_ASSERT(fd_node_list_.empty());
-  GPR_ASSERT(callback_map_.empty());
+  CHECK(fd_node_list_.empty());
+  CHECK(callback_map_.empty());
   ares_destroy(channel_);
 }
 
@@ -246,7 +247,7 @@ void AresResolver::Orphan() {
       if (!fd_node->already_shutdown) {
         GRPC_ARES_RESOLVER_TRACE_LOG("resolver: %p shutdown fd: %s", this,
                                      fd_node->polled_fd->GetName());
-        GPR_ASSERT(fd_node->polled_fd->ShutdownLocked(
+        CHECK(fd_node->polled_fd->ShutdownLocked(
             absl::CancelledError("AresResolver::Orphan")));
         fd_node->already_shutdown = true;
       }
@@ -513,7 +514,7 @@ void AresResolver::MaybeStartTimerLocked() {
 
 void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
-  GPR_ASSERT(fd_node->readable_registered);
+  CHECK(fd_node->readable_registered);
   fd_node->readable_registered = false;
   GRPC_ARES_RESOLVER_TRACE_LOG("OnReadable: fd: %d; request: %p; status: %s",
                                fd_node->as, this, status.ToString().c_str());
@@ -532,7 +533,7 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
 
 void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
-  GPR_ASSERT(fd_node->writable_registered);
+  CHECK(fd_node->writable_registered);
   fd_node->writable_registered = false;
   GRPC_ARES_RESOLVER_TRACE_LOG("OnWritable: fd: %d; request:%p; status: %s",
                                fd_node->as, this, status.ToString().c_str());
@@ -582,7 +583,7 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
                                           int /*timeouts*/,
                                           struct hostent* hostent) {
   auto* hostname_qa = static_cast<HostnameQueryArg*>(arg);
-  GPR_ASSERT(hostname_qa->pending_requests-- > 0);
+  CHECK_GT(hostname_qa->pending_requests--, 0);
   auto* ares_resolver = hostname_qa->ares_resolver;
   if (status != ARES_SUCCESS) {
     std::string error_msg =
@@ -643,9 +644,9 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
   if (hostname_qa->pending_requests == 0) {
     auto nh =
         ares_resolver->callback_map_.extract(hostname_qa->callback_map_id);
-    GPR_ASSERT(!nh.empty());
-    GPR_ASSERT(absl::holds_alternative<
-               EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
+    CHECK(!nh.empty());
+    CHECK(absl::holds_alternative<
+          EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
     auto callback = absl::get<EventEngine::DNSResolver::LookupHostnameCallback>(
         std::move(nh.mapped()));
     if (!hostname_qa->result.empty() || hostname_qa->error_status.ok()) {
@@ -670,10 +671,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   std::unique_ptr<QueryArg> qa(static_cast<QueryArg*>(arg));
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
-  GPR_ASSERT(!nh.empty());
-  GPR_ASSERT(
-      absl::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
-          nh.mapped()));
+  CHECK(!nh.empty());
+  CHECK(absl::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
+      nh.mapped()));
   auto callback = absl::get<EventEngine::DNSResolver::LookupSRVCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
@@ -726,10 +726,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   std::unique_ptr<QueryArg> qa(static_cast<QueryArg*>(arg));
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
-  GPR_ASSERT(!nh.empty());
-  GPR_ASSERT(
-      absl::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
-          nh.mapped()));
+  CHECK(!nh.empty());
+  CHECK(absl::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
+      nh.mapped()));
   auto callback = absl::get<EventEngine::DNSResolver::LookupTXTCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {

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

@@ -14,10 +14,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/debug/trace.h"
 
 #if GRPC_ARES == 1

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

@@ -20,6 +20,8 @@
 
 #include <CoreFoundation/CoreFoundation.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/cpu.h>
 
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
@@ -68,7 +70,7 @@ CFEventEngine::~CFEventEngine() {
                 HandleToString(handle).c_str());
       }
     }
-    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    CHECK(GPR_LIKELY(known_handles_.empty()));
     timer_manager_.Shutdown();
   }
   thread_pool_->Quiesce();

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.cc

@@ -249,9 +249,9 @@ void CFStreamEndpointImpl::Shutdown() {
   read_event_.SetShutdown(shutdownStatus);
   write_event_.SetShutdown(shutdownStatus);
 
-  CFReadStreamSetClient(cf_read_stream_, kCFStreamEventNone, nullptr, nullptr);
-  CFWriteStreamSetClient(cf_write_stream_, kCFStreamEventNone, nullptr,
-                         nullptr);
+  CFReadStreamSetDispatchQueue(cf_read_stream_, nullptr);
+  CFWriteStreamSetDispatchQueue(cf_write_stream_, nullptr);
+
   CFReadStreamClose(cf_read_stream_);
   CFWriteStreamClose(cf_write_stream_);
 }

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.cc

@@ -18,6 +18,7 @@
 #include <AvailabilityMacros.h>
 #ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
@@ -153,7 +154,7 @@ void DNSServiceResolverImpl::ResolveCallback(
 
   grpc_core::ReleasableMutexLock lock(&that->request_mu_);
   auto request_it = that->requests_.find(sdRef);
-  GPR_ASSERT(request_it != that->requests_.end());
+  CHECK(request_it != that->requests_.end());
 
   if (errorCode != kDNSServiceErr_NoError &&
       errorCode != kDNSServiceErr_NoSuchRecord) {

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.h

@@ -23,6 +23,7 @@
 #include <dns_sd.h>
 
 #include "absl/container/flat_hash_map.h"
+#include "absl/log/check.h"
 
 #include <grpc/event_engine/event_engine.h>
 
@@ -47,7 +48,7 @@ class DNSServiceResolverImpl
   explicit DNSServiceResolverImpl(std::shared_ptr<CFEventEngine> engine)
       : engine_(std::move((engine))) {}
   ~DNSServiceResolverImpl() override {
-    GPR_ASSERT(requests_.empty());
+    CHECK(requests_.empty());
     dispatch_release(queue_);
   }
 

data/src/core/lib/event_engine/channel_args_endpoint_config.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/channel_args_endpoint_config.h"
 
 #include <string>
@@ -20,6 +18,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 

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

@@ -14,12 +14,11 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/endpoint_config.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 

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

@@ -15,13 +15,12 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_COMMON_CLOSURES_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_COMMON_CLOSURES_H
 
-#include <grpc/support/port_platform.h>
-
 #include <utility>
 
 #include "absl/functional/any_invocable.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/default_event_engine.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/default_event_engine.h"
 
 #include <atomic>
@@ -22,6 +20,7 @@
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"

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

@@ -15,20 +15,13 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_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/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/promise/context.h"
-
-namespace grpc_core {
-template <>
-struct ContextType<grpc_event_engine::experimental::EventEngine> {};
-}  // namespace grpc_core
 
 namespace grpc_event_engine {
 namespace experimental {

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

@@ -12,13 +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/default_event_engine_factory.h"
 
 #include <memory>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #if defined(GPR_WINDOWS)
 #include "src/core/lib/event_engine/windows/windows_engine.h"

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

@@ -15,11 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 
 #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/event_engine.cc

@@ -11,9 +11,8 @@
 // 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 <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

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

@@ -0,0 +1,30 @@
+// 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_EVENT_ENGINE_CONTEXT_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_CONTEXT_H
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/promise/context.h"
+
+namespace grpc_core {
+
+template <>
+struct ContextType<grpc_event_engine::experimental::EventEngine> {};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_CONTEXT_H

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

@@ -15,10 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CAN_TRACK_ERRORS_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CAN_TRACK_ERRORS_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_event_engine {
 namespace experimental {