grpc 1.55.0 → 1.56.0

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

@@ -0,0 +1,146 @@
+// Copyright 2023 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_CF_ENGINE_CFSTREAM_ENDPOINT_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CFSTREAM_ENDPOINT_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include "absl/strings/str_format.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/cf_engine/cf_engine.h"
+#include "src/core/lib/event_engine/cf_engine/cftype_unique_ref.h"
+#include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class CFStreamEndpointImpl
+    : public grpc_core::RefCounted<CFStreamEndpointImpl> {
+ public:
+  CFStreamEndpointImpl(std::shared_ptr<CFEventEngine> engine,
+                       MemoryAllocator memory_allocator);
+  ~CFStreamEndpointImpl();
+
+  void Shutdown();
+
+  bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
+            const EventEngine::Endpoint::ReadArgs* args);
+  bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+             SliceBuffer* data, const EventEngine::Endpoint::WriteArgs* args);
+
+  const EventEngine::ResolvedAddress& GetPeerAddress() const {
+    return peer_address_;
+  }
+  const EventEngine::ResolvedAddress& GetLocalAddress() const {
+    return local_address_;
+  }
+
+ public:
+  void Connect(absl::AnyInvocable<void(absl::Status)> on_connect,
+               EventEngine::ResolvedAddress addr);
+  bool CancelConnect(absl::Status status);
+
+ private:
+  void DoWrite(absl::AnyInvocable<void(absl::Status)> on_writable,
+               SliceBuffer* data);
+  void DoRead(absl::AnyInvocable<void(absl::Status)> on_read,
+              SliceBuffer* buffer);
+
+ private:
+  static void* Retain(void* info) {
+    auto that = static_cast<CFStreamEndpointImpl*>(info);
+    return that->Ref().release();
+  }
+
+  static void Release(void* info) {
+    auto that = static_cast<CFStreamEndpointImpl*>(info);
+    that->Unref();
+  }
+
+  static void ReadCallback(CFReadStreamRef stream, CFStreamEventType type,
+                           void* client_callback_info);
+  static void WriteCallback(CFWriteStreamRef stream, CFStreamEventType type,
+                            void* client_callback_info);
+
+ private:
+  CFTypeUniqueRef<CFReadStreamRef> cf_read_stream_;
+  CFTypeUniqueRef<CFWriteStreamRef> cf_write_stream_;
+
+  std::shared_ptr<CFEventEngine> engine_;
+
+  EventEngine::ResolvedAddress peer_address_;
+  EventEngine::ResolvedAddress local_address_;
+  std::string peer_address_string_;
+  std::string local_address_string_;
+  MemoryAllocator memory_allocator_;
+
+  LockfreeEvent open_event_;
+  LockfreeEvent read_event_;
+  LockfreeEvent write_event_;
+};
+
+class CFStreamEndpoint : public EventEngine::Endpoint {
+ public:
+  CFStreamEndpoint(std::shared_ptr<CFEventEngine> engine,
+                   MemoryAllocator memory_allocator) {
+    impl_ = grpc_core::MakeRefCounted<CFStreamEndpointImpl>(
+        std::move(engine), std::move(memory_allocator));
+  }
+  ~CFStreamEndpoint() override { impl_->Shutdown(); }
+
+  bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
+            const ReadArgs* args) override {
+    return impl_->Read(std::move(on_read), buffer, args);
+  }
+  bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+             SliceBuffer* data, const WriteArgs* args) override {
+    return impl_->Write(std::move(on_writable), data, args);
+  }
+
+  const EventEngine::ResolvedAddress& GetPeerAddress() const override {
+    return impl_->GetPeerAddress();
+  }
+  const EventEngine::ResolvedAddress& GetLocalAddress() const override {
+    return impl_->GetLocalAddress();
+  }
+
+ public:
+  void Connect(absl::AnyInvocable<void(absl::Status)> on_connect,
+               EventEngine::ResolvedAddress addr) {
+    impl_->Connect(std::move(on_connect), std::move(addr));
+  }
+  bool CancelConnect(absl::Status status) {
+    return impl_->CancelConnect(std::move(status));
+  }
+
+ private:
+  grpc_core::RefCountedPtr<CFStreamEndpointImpl> impl_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CFSTREAM_ENDPOINT_H

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

@@ -0,0 +1,79 @@
+// Copyright 2023 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_CF_ENGINE_CFTYPE_UNIQUE_REF_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CFTYPE_UNIQUE_REF_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+
+#include <CoreFoundation/CoreFoundation.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+template <typename T>
+class CFTypeUniqueRef {
+  static_assert(std::is_convertible<T, CFTypeRef>::value,
+                "T should be `CFXxxRef` type");
+
+ public:
+  /* implicit */
+  CFTypeUniqueRef(T cf_type_ref = nullptr) : cf_type_ref_(cf_type_ref) {}
+  ~CFTypeUniqueRef() { reset(); }
+
+  CFTypeUniqueRef(CFTypeUniqueRef const&) = delete;
+  CFTypeUniqueRef& operator=(CFTypeUniqueRef const&) = delete;
+
+  CFTypeUniqueRef(CFTypeUniqueRef&& other) : cf_type_ref_(other.release()){};
+  CFTypeUniqueRef& operator=(CFTypeUniqueRef&& other) {
+    reset(other.release());
+    return *this;
+  }
+
+  operator T() { return cf_type_ref_; }
+
+  // Note: this is for passing a CFTypeRef as output parameter to a CF API, the
+  // current ref is released (if any) regardless of whether new value is set
+  T* operator&() {
+    reset();
+    return &cf_type_ref_;
+  }
+
+  T release() {
+    T old = cf_type_ref_;
+    cf_type_ref_ = nullptr;
+    return old;
+  }
+
+  void reset(T other = nullptr) {
+    if (cf_type_ref_ == other) {
+      return;
+    }
+    T old = cf_type_ref_;
+    cf_type_ref_ = other;
+    if (old) {
+      CFRelease(old);
+    }
+  }
+
+ private:
+  T cf_type_ref_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CFTYPE_UNIQUE_REF_H

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

@@ -32,6 +32,10 @@
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/sync.h"
 
+#ifdef GRPC_MAXIMIZE_THREADYNESS
+#include "src/core/lib/event_engine/thready_event_engine/thready_event_engine.h"  // IWYU pragma: keep
+#endif
+
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -57,13 +61,21 @@ void EventEngineFactoryReset() {
   g_event_engine->reset();
 }
 
-std::unique_ptr<EventEngine> CreateEventEngine() {
+std::unique_ptr<EventEngine> CreateEventEngineInner() {
   if (auto* factory = g_event_engine_factory.load()) {
     return (*factory)();
   }
   return DefaultEventEngineFactory();
 }
 
+std::unique_ptr<EventEngine> CreateEventEngine() {
+#ifdef GRPC_MAXIMIZE_THREADYNESS
+  return std::make_unique<ThreadyEventEngine>(CreateEventEngineInner());
+#else
+  return CreateEventEngineInner();
+#endif
+}
+
 std::shared_ptr<EventEngine> GetDefaultEventEngine(
     grpc_core::SourceLocation location) {
   grpc_core::MutexLock lock(&*g_mu);

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

@@ -20,7 +20,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#ifdef GPR_WINDOWS
+#if defined(GPR_WINDOWS)
 #include "src/core/lib/event_engine/windows/windows_engine.h"
 
 namespace grpc_event_engine {
@@ -32,7 +32,19 @@ std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
-#else  // not GPR_WINDOWS
+#elif defined(GRPC_CFSTREAM)
+#include "src/core/lib/event_engine/cf_engine/cf_engine.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
+  return std::make_unique<CFEventEngine>();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+#else
 #include "src/core/lib/event_engine/posix_engine/posix_engine.h"
 
 namespace grpc_event_engine {

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

@@ -43,12 +43,12 @@ class Poller {
   //  * Poller::WorkResult::kKicked if it was Kicked. A poller that was Kicked
   //  may still process some events and if so, it may have run the
   //  schedule_poll_again callback function synchronously. When the poller
-  //  returns Poller::WorkResult::kKicked tts upto the user to determine
+  //  returns Poller::WorkResult::kKicked it's up to the user to determine
   //  if the schedule_poll_again callback has run or not.
   //  * Poller::WorkResult::kDeadlineExceeded if timeout occurred. The
   //  schedule_poll_again callback is not run in this case.
   //  * Poller::WorkResult::kOk, otherwise indicating that the
-  //  schedule_poll_again callback function was run synchonously before some
+  //  schedule_poll_again callback function was run synchronously before some
   //  events were processed.
   virtual WorkResult Work(EventEngine::Duration timeout,
                           absl::FunctionRef<void()> schedule_poll_again) = 0;

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

@@ -37,6 +37,10 @@ class PosixEndpointWithFdSupport : public EventEngine::Endpoint {
   /// Returns the file descriptor associated with the posix endpoint.
   virtual int GetWrappedFd() = 0;
 
+  /// Returns if the Endpoint supports tracking events from errmsg queues on
+  /// posix systems.
+  virtual bool CanTrackErrors() = 0;
+
   /// Shutdown the endpoint. This function call should trigger execution of
   /// any pending endpoint Read/Write callbacks with appropriate error
   /// absl::Status. After this function call any subsequent endpoint

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

@@ -349,7 +349,7 @@ void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
       }
     }
     write_closure_->SetShutdown(why);
-    write_closure_->SetShutdown(why);
+    error_closure_->SetShutdown(why);
   }
 }
 

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

@@ -86,7 +86,7 @@ void LockfreeEvent::DestroyEvent() {
     // pattern to prevent error retention in a deleted object
   } while (!state_.compare_exchange_strong(curr, kShutdownBit,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed));
+                                           std::memory_order_acquire));
 }
 
 void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
@@ -103,14 +103,9 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
       case kClosureNotReady: {
         // kClosureNotReady -> <closure>.
 
-        // We're guaranteed by API that there's an acquire barrier before here,
-        // so there's no need to double-dip and this can be a release-only.
-
-        // The release itself pairs with the acquire half of a set_ready full
-        // barrier.
         if (state_.compare_exchange_strong(
                 curr, reinterpret_cast<intptr_t>(closure),
-                std::memory_order_acq_rel, std::memory_order_relaxed)) {
+                std::memory_order_acq_rel, std::memory_order_acquire)) {
           return;  // Successful. Return
         }
 
@@ -122,13 +117,9 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
         // successful. If not, the state most likely transitioned to shutdown.
         // We should retry.
 
-        // This can be a no-barrier cas since the state is being transitioned to
-        // kClosureNotReady; set_ready and set_shutdown do not schedule any
-        // closure when transitioning out of CLOSURE_NO_READY state (i.e there
-        // is no other code that needs to 'happen-after' this)
         if (state_.compare_exchange_strong(curr, kClosureNotReady,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed)) {
+                                           std::memory_order_acquire)) {
           scheduler_->Run(closure);
           return;  // Successful. Return.
         }
@@ -175,7 +166,7 @@ bool LockfreeEvent::SetShutdown(absl::Status shutdown_error) {
         // doesn't need a barrier
         if (state_.compare_exchange_strong(curr, new_state,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed)) {
+                                           std::memory_order_acquire)) {
           return true;  // early out
         }
         break;  // retry
@@ -196,7 +187,7 @@ bool LockfreeEvent::SetShutdown(absl::Status shutdown_error) {
         // loading the shutdown state.
         if (state_.compare_exchange_strong(curr, new_state,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed)) {
+                                           std::memory_order_acquire)) {
           auto closure = reinterpret_cast<PosixEngineClosure*>(curr);
           closure->SetStatus(shutdown_error);
           scheduler_->Run(closure);
@@ -225,11 +216,9 @@ void LockfreeEvent::SetReady() {
       }
 
       case kClosureNotReady: {
-        // No barrier required as we're transitioning to a state that does not
-        // involve a closure
         if (state_.compare_exchange_strong(curr, kClosureReady,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed)) {
+                                           std::memory_order_acquire)) {
           return;  // early out
         }
         break;  // retry
@@ -242,7 +231,7 @@ void LockfreeEvent::SetReady() {
           return;
         } else if (state_.compare_exchange_strong(curr, kClosureNotReady,
                                                   std::memory_order_acq_rel,
-                                                  std::memory_order_relaxed)) {
+                                                  std::memory_order_acquire)) {
           // Full cas: acquire pairs with this cas' release in the event of a
           // spurious set_ready; release pairs with this or the acquire in
           // notify_on (or set_shutdown)

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

@@ -493,6 +493,8 @@ class PosixEndpointImpl : public grpc_core::RefCounted<PosixEndpointImpl> {
 
   int GetWrappedFd() { return fd_; }
 
+  bool CanTrackErrors() const { return poller_->CanTrackErrors(); }
+
   void MaybeShutdown(
       absl::Status why,
       absl::AnyInvocable<void(absl::StatusOr<int> release_fd)> on_release_fd);
@@ -635,6 +637,8 @@ class PosixEndpoint : public PosixEndpointWithFdSupport {
 
   int GetWrappedFd() override { return impl_->GetWrappedFd(); }
 
+  bool CanTrackErrors() override { return impl_->CanTrackErrors(); }
+
   void Shutdown(absl::AnyInvocable<void(absl::StatusOr<int> release_fd)>
                     on_release_fd) override {
     if (!shutdown_.exchange(true, std::memory_order_acq_rel)) {
@@ -691,6 +695,11 @@ class PosixEndpoint : public PosixEndpointWithFdSupport {
         "PosixEndpoint::GetWrappedFd not supported on this platform");
   }
 
+  bool CanTrackErrors() override {
+    grpc_core::Crash(
+        "PosixEndpoint::CanTrackErrors not supported on this platform");
+  }
+
   void Shutdown(absl::AnyInvocable<void(absl::StatusOr<int> release_fd)>
                     on_release_fd) override {
     grpc_core::Crash("PosixEndpoint::Shutdown not supported on this platform");

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

@@ -44,6 +44,7 @@
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/utils.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 
@@ -60,6 +61,15 @@
 
 // IWYU pragma: no_include <ratio>
 
+// TODO(eryu): remove this GRPC_CFSTREAM condition when the CFEngine is ready.
+// The posix poller currently crashes iOS.
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
+    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
+#define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING true
+#else
+#define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING false
+#endif
+
 using namespace std::chrono_literals;
 
 namespace grpc_event_engine {
@@ -333,15 +343,18 @@ PosixEnginePollerManager::~PosixEnginePollerManager() {
 
 PosixEventEngine::PosixEventEngine(PosixEventPoller* poller)
     : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
-      executor_(std::make_shared<ThreadPool>()),
+      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
       timer_manager_(executor_) {
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   poller_manager_ = std::make_shared<PosixEnginePollerManager>(poller);
+#endif
 }
 
 PosixEventEngine::PosixEventEngine()
     : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
-      executor_(std::make_shared<ThreadPool>()),
+      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
       timer_manager_(executor_) {
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   poller_manager_ = std::make_shared<PosixEnginePollerManager>(executor_);
   // The threadpool must be instantiated after the poller otherwise, the
   // process will deadlock when forking.
@@ -350,6 +363,7 @@ PosixEventEngine::PosixEventEngine()
       PollerWorkInternal(poller_manager);
     });
   }
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 void PosixEventEngine::PollerWorkInternal(
@@ -420,11 +434,11 @@ PosixEventEngine::~PosixEventEngine() {
     GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
   }
   timer_manager_.Shutdown();
-#ifdef GRPC_POSIX_SOCKET_TCP
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   if (poller_manager_ != nullptr) {
     poller_manager_->TriggerShutdown();
   }
-#endif  // GRPC_POSIX_SOCKET_TCP
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   executor_->Quiesce();
 }
 
@@ -481,7 +495,7 @@ std::unique_ptr<EventEngine::DNSResolver> PosixEventEngine::GetDNSResolver(
 bool PosixEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
 
 bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
-#ifdef GRPC_POSIX_SOCKET_TCP
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   int connection_handle = handle.keys[0];
   if (connection_handle <= 0) {
     return false;
@@ -530,17 +544,17 @@ bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
     delete ac;
   }
   return connection_cancel_success;
-#else   // GRPC_POSIX_SOCKET_TCP
+#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   grpc_core::Crash(
       "EventEngine::CancelConnect is not supported on this platform");
-#endif  // GRPC_POSIX_SOCKET_TCP
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 EventEngine::ConnectionHandle PosixEventEngine::Connect(
     OnConnectCallback on_connect, const ResolvedAddress& addr,
     const EndpointConfig& args, MemoryAllocator memory_allocator,
     Duration timeout) {
-#ifdef GRPC_POSIX_SOCKET_TCP
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   GPR_ASSERT(poller_manager_ != nullptr);
   PosixTcpOptions options = TcpOptionsFromEndpointConfig(args);
   absl::StatusOr<PosixSocketWrapper::PosixSocketCreateResult> socket =
@@ -553,16 +567,16 @@ EventEngine::ConnectionHandle PosixEventEngine::Connect(
   return ConnectInternal((*socket).sock, std::move(on_connect),
                          (*socket).mapped_target_addr,
                          std::move(memory_allocator), options, timeout);
-#else   // GRPC_POSIX_SOCKET_TCP
+#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   grpc_core::Crash("EventEngine::Connect is not supported on this platform");
-#endif  // GRPC_POSIX_SOCKET_TCP
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 std::unique_ptr<PosixEndpointWithFdSupport>
 PosixEventEngine::CreatePosixEndpointFromFd(int fd,
                                             const EndpointConfig& config,
                                             MemoryAllocator memory_allocator) {
-#ifdef GRPC_POSIX_SOCKET_TCP
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   GPR_DEBUG_ASSERT(fd > 0);
   PosixEventPoller* poller = poller_manager_->Poller();
   GPR_DEBUG_ASSERT(poller != nullptr);
@@ -571,11 +585,11 @@ PosixEventEngine::CreatePosixEndpointFromFd(int fd,
   return CreatePosixEndpoint(handle, nullptr, shared_from_this(),
                              std::move(memory_allocator),
                              TcpOptionsFromEndpointConfig(config));
-#else   // GRPC_POSIX_SOCKET_TCP
+#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   grpc_core::Crash(
       "PosixEventEngine::CreatePosixEndpointFromFd is not supported on "
       "this platform");
-#endif  // GRPC_POSIX_SOCKET_TCP
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
@@ -584,7 +598,7 @@ PosixEventEngine::CreateListener(
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const EndpointConfig& config,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
-#ifdef GRPC_POSIX_SOCKET_TCP
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   PosixEventEngineWithFdSupport::PosixAcceptCallback posix_on_accept =
       [on_accept_cb = std::move(on_accept)](
           int /*listener_fd*/, std::unique_ptr<EventEngine::Endpoint> ep,
@@ -596,10 +610,10 @@ PosixEventEngine::CreateListener(
       std::move(posix_on_accept), std::move(on_shutdown), config,
       std::move(memory_allocator_factory), poller_manager_->Poller(),
       shared_from_this());
-#else   // GRPC_POSIX_SOCKET_TCP
+#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   grpc_core::Crash(
       "EventEngine::CreateListener is not supported on this platform");
-#endif  // GRPC_POSIX_SOCKET_TCP
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 absl::StatusOr<std::unique_ptr<PosixListenerWithFdSupport>>
@@ -608,15 +622,15 @@ PosixEventEngine::CreatePosixListener(
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const EndpointConfig& config,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
-#ifdef GRPC_POSIX_SOCKET_TCP
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   return std::make_unique<PosixEngineListener>(
       std::move(on_accept), std::move(on_shutdown), config,
       std::move(memory_allocator_factory), poller_manager_->Poller(),
       shared_from_this());
-#else   // GRPC_POSIX_SOCKET_TCP
+#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   grpc_core::Crash(
       "EventEngine::CreateListener is not supported on this platform");
-#endif  // GRPC_POSIX_SOCKET_TCP
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 }  // namespace experimental

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

@@ -38,7 +38,7 @@
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
-#include "src/core/lib/event_engine/thread_pool.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/surface/init_internally.h"

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

@@ -64,7 +64,7 @@ PosixEngineListenerImpl::PosixEngineListenerImpl(
 absl::StatusOr<int> PosixEngineListenerImpl::Bind(
     const EventEngine::ResolvedAddress& addr,
     PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_bind_new_fd) {
-  absl::MutexLock lock(&this->mu_);
+  grpc_core::MutexLock lock(&this->mu_);
   if (this->started_) {
     return absl::FailedPreconditionError(
         "Listener is already started, ports can no longer be bound");
@@ -254,7 +254,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::Shutdown() {
 }
 
 absl::Status PosixEngineListenerImpl::Start() {
-  absl::MutexLock lock(&this->mu_);
+  grpc_core::MutexLock lock(&this->mu_);
   // Start each asynchronous acceptor.
   GPR_ASSERT(!this->started_);
   this->started_ = true;
@@ -267,7 +267,7 @@ absl::Status PosixEngineListenerImpl::Start() {
 void PosixEngineListenerImpl::TriggerShutdown() {
   // This would get invoked from the destructor of the parent
   // PosixEngineListener object.
-  absl::MutexLock lock(&this->mu_);
+  grpc_core::MutexLock lock(&this->mu_);
   for (auto it = acceptors_.begin(); it != acceptors_.end(); it++) {
     // Trigger shutdown of each asynchronous acceptor. This in-turn calls
     // ShutdownHandle on the associated poller event handle. It may also
@@ -278,7 +278,7 @@ void PosixEngineListenerImpl::TriggerShutdown() {
 }
 
 PosixEngineListenerImpl::~PosixEngineListenerImpl() {
-  // This should get invoked only after all the AsyncConnectionAcceptor's have
+  // This should get invoked only after all the AsyncConnectionAcceptors have
   // been destroyed. This is because each AsyncConnectionAcceptor has a
   // shared_ptr ref to the parent PosixEngineListenerImpl.
   if (on_shutdown_ != nullptr) {