grpc 1.55.3 → 1.56.0.pre3

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"
 
@@ -342,7 +343,7 @@ 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);
@@ -351,7 +352,7 @@ PosixEventEngine::PosixEventEngine(PosixEventPoller* poller)
 
 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_);

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"
@@ -196,7 +196,6 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;
-  // Caution!! The timer implementation cannot create any fds. See #20418.
   TaskHandle RunAfter(Duration when, Closure* closure) override;
   TaskHandle RunAfter(Duration when,
                       absl::AnyInvocable<void()> closure) override;

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

@@ -23,9 +23,7 @@
 #include <sys/socket.h>  // IWYU pragma: keep
 #include <unistd.h>      // IWYU pragma: keep
 
-#include <atomic>
 #include <string>
-#include <tuple>
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
@@ -43,7 +41,6 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 
 namespace grpc_event_engine {
@@ -67,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");
@@ -139,32 +136,6 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
       switch (errno) {
         case EINTR:
           continue;
-        case EMFILE:
-          // When the process runs out of fds, accept4() returns EMFILE. When
-          // this happens, the connection is left in the accept queue until
-          // either a read event triggers the on_read callback, or time has
-          // passed and the accept should be re-tried regardless. This callback
-          // is not cancelled, so a spurious wakeup may occur even when there's
-          // nothing to accept. This is not a performant code path, but if an fd
-          // limit has been reached, the system is likely in an unhappy state
-          // regardless.
-          GRPC_LOG_EVERY_N_SEC(1, GPR_ERROR, "%s",
-                               "File descriptor limit reached. Retrying.");
-          handle_->NotifyOnRead(notify_on_accept_);
-          // Do not schedule another timer if one is already armed.
-          if (retry_timer_armed_.exchange(true)) return;
-          // Hold a ref while the retry timer is waiting, to prevent listener
-          // destruction and the races that would ensue.
-          Ref();
-          std::ignore =
-              engine_->RunAfter(grpc_core::Duration::Seconds(1), [this]() {
-                retry_timer_armed_.store(false);
-                if (!handle_->IsHandleShutdown()) {
-                  handle_->SetReadable();
-                }
-                Unref();
-              });
-          return;
         case EAGAIN:
         case ECONNABORTED:
           handle_->NotifyOnRead(notify_on_accept_);
@@ -283,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;
@@ -296,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
@@ -307,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) {

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

@@ -28,7 +28,6 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/synchronization/mutex.h"
 
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
@@ -36,6 +35,7 @@
 #include <grpc/event_engine/slice_buffer.h>
 
 #include "src/core/lib/event_engine/posix.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -79,7 +79,7 @@ class PosixEngineListenerImpl
   // This class represents accepting for one bind fd belonging to the listener.
   // Each AsyncConnectionAcceptor takes a ref to the parent
   // PosixEngineListenerImpl object. So the PosixEngineListenerImpl can be
-  // deleted only after all AsyncConnectionAcceptor's get destroyed.
+  // deleted only after all AsyncConnectionAcceptors get destroyed.
   class AsyncConnectionAcceptor {
    public:
     AsyncConnectionAcceptor(std::shared_ptr<EventEngine> engine,
@@ -121,9 +121,6 @@ class PosixEngineListenerImpl
     ListenerSocketsContainer::ListenerSocket socket_;
     EventHandle* handle_;
     PosixEngineClosure* notify_on_accept_;
-    // Tracks the status of a backup timer to retry accept4 calls after file
-    // descriptor exhaustion.
-    std::atomic<bool> retry_timer_armed_{false};
   };
   class ListenerAsyncAcceptors : public ListenerSocketsContainer {
    public:
@@ -146,12 +143,11 @@ class PosixEngineListenerImpl
     absl::StatusOr<ListenerSocket> Find(
         const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
             addr) override {
-      for (auto acceptor = acceptors_.begin(); acceptor != acceptors_.end();
-           ++acceptor) {
-        if ((*acceptor)->Socket().addr.size() == addr.size() &&
-            memcmp((*acceptor)->Socket().addr.address(), addr.address(),
+      for (auto* acceptor : acceptors_) {
+        if (acceptor->Socket().addr.size() == addr.size() &&
+            memcmp(acceptor->Socket().addr.address(), addr.address(),
                    addr.size()) == 0) {
-          return (*acceptor)->Socket();
+          return acceptor->Socket();
         }
       }
       return absl::NotFoundError("Socket not found!");
@@ -175,7 +171,7 @@ class PosixEngineListenerImpl
   friend class AsyncConnectionAcceptor;
   // The mutex ensures thread safety when multiple threads try to call Bind
   // and Start in parallel.
-  absl::Mutex mu_;
+  grpc_core::Mutex mu_;
   PosixEventPoller* poller_;
   PosixTcpOptions options_;
   std::shared_ptr<EventEngine> engine_;

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

@@ -33,7 +33,7 @@
 
 #include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/posix_engine/timer.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/notification.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/thd.h"

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

@@ -22,6 +22,12 @@
 namespace grpc_event_engine {
 namespace experimental {
 
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+bool g_event_engine_supports_fd = true;
+#else
+bool g_event_engine_supports_fd = false;
+#endif
+
 bool UseEventEngineClient() {
 // TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
 // available for other platforms.
@@ -48,7 +54,7 @@ bool UseEventEngineListener() {
 
 bool EventEngineSupportsFd() {
 #if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
-  return true;
+  return g_event_engine_supports_fd;
 #else
   return false;
 #endif