grpc 1.74.1 → 1.75.0.pre1

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

@@ -0,0 +1,107 @@
+// Copyright 2025 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_CFSOCKET_LISTENER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CFSOCKET_LISTENER_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+#include <AvailabilityMacros.h>
+#ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <grpc/event_engine/event_engine.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/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_event_engine::experimental {
+
+class CFSocketListenerImpl
+    : public grpc_core::RefCounted<CFSocketListenerImpl> {
+ public:
+  CFSocketListenerImpl(
+      std::shared_ptr<CFEventEngine> engine,
+      EventEngine::Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory);
+  ~CFSocketListenerImpl();
+
+  absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr);
+  absl::Status Start();
+
+  void Shutdown();
+
+ private:
+  static const void* Retain(const void* info) {
+    auto that = static_cast<const CFSocketListenerImpl*>(info);
+    return that->Ref().release();
+  }
+
+  static void Release(const void* info) {
+    auto that = static_cast<const CFSocketListenerImpl*>(info);
+    that->Unref();
+  }
+
+  static void handleConnect(CFSocketRef s, CFSocketCallBackType type,
+                            CFDataRef address, const void* data, void* info);
+
+ private:
+  std::shared_ptr<CFEventEngine> engine_;
+  dispatch_queue_t queue_ = dispatch_queue_create("cfsocket_listener", nullptr);
+
+  grpc_core::Mutex mu_;
+  bool started_ ABSL_GUARDED_BY(mu_) = false;
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  std::vector<std::tuple<CFTypeUniqueRef<CFSocketRef>>> ipv6cfsocks_
+      ABSL_GUARDED_BY(mu_);
+  CFRunLoopRef runloop_ ABSL_GUARDED_BY(mu_);
+
+  EventEngine::Listener::AcceptCallback on_accept_;
+  absl::AnyInvocable<void(absl::Status)> on_shutdown_;
+  std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory_;
+};
+
+class CFSocketListener : public EventEngine::Listener {
+ public:
+  CFSocketListener(
+      std::shared_ptr<CFEventEngine> engine, Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      : impl_(grpc_core::MakeRefCounted<CFSocketListenerImpl>(
+            std::move(engine), std::move(on_accept), std::move(on_shutdown),
+            config, std::move(memory_allocator_factory))) {}
+
+  ~CFSocketListener() override { impl_->Shutdown(); }
+
+  absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr) override {
+    return impl_->Bind(addr);
+  };
+
+  absl::Status Start() override { return impl_->Start(); };
+
+ private:
+  grpc_core::RefCountedPtr<CFSocketListenerImpl> impl_;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
+#endif  // GPR_APPLE
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CFSOCKET_LISTENER_H

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

@@ -72,6 +72,26 @@ bool CFStreamEndpointImpl::CancelConnect(absl::Status status) {
   return open_event_.SetShutdown(std::move(status));
 }
 
+void CFStreamEndpointImpl::AcceptSocket(
+    absl::AnyInvocable<void(absl::Status)> on_connect,
+    CFSocketNativeHandle sock, const EventEngine::ResolvedAddress& addr) {
+  peer_address_ = addr;
+  auto host_port = ResolvedAddressToNormalizedString(peer_address_);
+  if (!host_port.ok()) {
+    on_connect(std::move(host_port).status());
+    return;
+  }
+
+  peer_address_string_ = host_port.value();
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::AcceptSocket, host_port: "
+      << peer_address_string_;
+
+  CFStreamCreatePairWithSocket(nullptr, sock, &cf_read_stream_,
+                               &cf_write_stream_);
+  SetupStreams(std::move(on_connect));
+}
+
 void CFStreamEndpointImpl::Connect(
     absl::AnyInvocable<void(absl::Status)> on_connect,
     EventEngine::ResolvedAddress addr) {
@@ -105,6 +125,11 @@ void CFStreamEndpointImpl::Connect(
   CFStreamCreatePairWithSocketToHost(NULL, host, port, &cf_read_stream_,
                                      &cf_write_stream_);
 
+  SetupStreams(std::move(on_connect));
+}
+
+void CFStreamEndpointImpl::SetupStreams(
+    absl::AnyInvocable<void(absl::Status)> on_connect) {
   CFStreamClientContext cf_context = {0, this, Retain, Release, nullptr};
   CFReadStreamSetClient(
       cf_read_stream_,
@@ -223,9 +248,9 @@ CFStreamEndpointImpl::CFStreamEndpointImpl(
     std::shared_ptr<CFEventEngine> engine, MemoryAllocator memory_allocator)
     : engine_(std::move(engine)),
       memory_allocator_(std::move(memory_allocator)),
-      open_event_(engine_.get()),
-      read_event_(engine_.get()),
-      write_event_(engine_.get()) {
+      open_event_(engine_->thread_pool()),
+      read_event_(engine_->thread_pool()),
+      write_event_(engine_->thread_pool()) {
   open_event_.InitEvent();
   read_event_.InitEvent();
   write_event_.InitEvent();
@@ -235,6 +260,9 @@ CFStreamEndpointImpl::~CFStreamEndpointImpl() {
   open_event_.DestroyEvent();
   read_event_.DestroyEvent();
   write_event_.DestroyEvent();
+
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::~CFStreamEndpointImpl: this: " << this;
 }
 
 void CFStreamEndpointImpl::Shutdown() {

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

@@ -60,7 +60,13 @@ class CFStreamEndpointImpl
                EventEngine::ResolvedAddress addr);
   bool CancelConnect(absl::Status status);
 
+  void AcceptSocket(absl::AnyInvocable<void(absl::Status)> on_connect,
+                    CFSocketNativeHandle sock,
+                    const EventEngine::ResolvedAddress& addr);
+
  private:
+  void SetupStreams(absl::AnyInvocable<void(absl::Status)> on_connect);
+
   void DoWrite(absl::AnyInvocable<void(absl::Status)> on_writable,
                SliceBuffer* data);
   void DoRead(absl::AnyInvocable<void(absl::Status)> on_read,
@@ -137,6 +143,12 @@ class CFStreamEndpoint : public EventEngine::Endpoint {
     return impl_->CancelConnect(std::move(status));
   }
 
+  void AcceptSocket(absl::AnyInvocable<void(absl::Status)> on_connect,
+                    CFSocketNativeHandle sock,
+                    const EventEngine::ResolvedAddress& addr) {
+    return impl_->AcceptSocket(std::move(on_connect), sock, addr);
+  }
+
  private:
   grpc_core::RefCountedPtr<CFStreamEndpointImpl> impl_;
 };

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

@@ -60,9 +60,9 @@ class Epoll1EventHandle : public EventHandle {
   Epoll1EventHandle(const FileDescriptor& fd, Epoll1Poller* poller)
       : fd_(fd),
         poller_(poller),
-        read_closure_(poller->GetScheduler()),
-        write_closure_(poller->GetScheduler()),
-        error_closure_(poller->GetScheduler()) {
+        read_closure_(poller->GetThreadPool()),
+        write_closure_(poller->GetThreadPool()),
+        error_closure_(poller->GetThreadPool()) {
     read_closure_.InitEvent();
     write_closure_.InitEvent();
     error_closure_.InitEvent();
@@ -217,7 +217,7 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
   }
   if (on_done != nullptr) {
     on_done->SetStatus(absl::OkStatus());
-    poller_->GetScheduler()->Run(on_done);
+    poller_->GetThreadPool()->Run(on_done);
   }
 }
 
@@ -243,8 +243,8 @@ void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
   }
 }
 
-Epoll1Poller::Epoll1Poller(Scheduler* scheduler)
-    : scheduler_(scheduler), was_kicked_(false), closed_(false) {
+Epoll1Poller::Epoll1Poller(std::shared_ptr<ThreadPool> thread_pool)
+    : thread_pool_(thread_pool), was_kicked_(false), closed_(false) {
   g_epoll_set_.epfd = posix_interface().EpollCreateAndCloexec().value();
   wakeup_fd_ = CreateWakeupFd(&posix_interface()).value();
   CHECK(wakeup_fd_ != nullptr);
@@ -493,10 +493,11 @@ void Epoll1Poller::ResetKickState() {
   was_kicked_ = false;
 }
 
-std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(Scheduler* scheduler) {
+std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(
+    std::shared_ptr<ThreadPool> thread_pool) {
   static bool kEpoll1PollerSupported = InitEpoll1PollerLinux();
   if (kEpoll1PollerSupported) {
-    return std::make_shared<Epoll1Poller>(scheduler);
+    return std::make_shared<Epoll1Poller>(std::move(thread_pool));
   }
   return nullptr;
 }
@@ -511,7 +512,7 @@ namespace grpc_event_engine::experimental {
 using ::grpc_event_engine::experimental::EventEngine;
 using ::grpc_event_engine::experimental::Poller;
 
-Epoll1Poller::Epoll1Poller(Scheduler* /* engine */) {
+Epoll1Poller::Epoll1Poller(std::shared_ptr<ThreadPool> /* thread_pool */) {
   grpc_core::Crash("unimplemented");
 }
 
@@ -548,7 +549,8 @@ void Epoll1Poller::ResetKickState() { grpc_core::Crash("unimplemented"); }
 
 // If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
 // nullptr.
-std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(Scheduler* /*scheduler*/) {
+std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(
+    std::shared_ptr<ThreadPool> /*thread_pool*/) {
   return nullptr;
 }
 

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

@@ -30,6 +30,7 @@
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/sync.h"
 
@@ -46,7 +47,7 @@ class Epoll1EventHandle;
 // Definition of epoll1 based poller.
 class Epoll1Poller : public PosixEventPoller {
  public:
-  explicit Epoll1Poller(Scheduler* scheduler);
+  explicit Epoll1Poller(std::shared_ptr<ThreadPool> thread_pool);
   EventHandle* CreateHandle(FileDescriptor fd, absl::string_view name,
                             bool track_err) override;
   Poller::WorkResult Work(
@@ -54,7 +55,7 @@ class Epoll1Poller : public PosixEventPoller {
       absl::FunctionRef<void()> schedule_poll_again) override;
   std::string Name() override { return "epoll1"; }
   void Kick() override;
-  Scheduler* GetScheduler() { return scheduler_; }
+  ThreadPool* GetThreadPool() { return thread_pool_.get(); }
   bool CanTrackErrors() const override {
 #ifdef GRPC_POSIX_SOCKET_TCP
     return KernelSupportsErrqueue();
@@ -109,7 +110,7 @@ class Epoll1Poller : public PosixEventPoller {
   struct EpollSet {};
 #endif
   grpc_core::Mutex mu_;
-  Scheduler* scheduler_;
+  std::shared_ptr<ThreadPool> thread_pool_;
   // A singleton epoll set
   EpollSet g_epoll_set_;
   bool was_kicked_ ABSL_GUARDED_BY(mu_);
@@ -123,7 +124,8 @@ class Epoll1Poller : public PosixEventPoller {
 
 // Return an instance of a epoll1 based poller tied to the specified event
 // engine.
-std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(Scheduler* scheduler);
+std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(
+    std::shared_ptr<ThreadPool> thread_pool);
 
 }  // namespace grpc_event_engine::experimental
 

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

@@ -72,7 +72,7 @@ class PollEventHandle : public EventHandle {
       : fd_(fd),
         pending_actions_(0),
         poller_handles_list_(this),
-        scheduler_(poller->GetScheduler()),
+        thread_pool_(poller->GetThreadPool()),
         poller_(std::move(poller)),
         is_orphaned_(false),
         is_shutdown_(false),
@@ -175,7 +175,7 @@ class PollEventHandle : public EventHandle {
   void Unref() {
     if (ref_count_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
       if (on_done_ != nullptr) {
-        scheduler_->Run(on_done_);
+        thread_pool_->Run(on_done_);
       }
       delete this;
     }
@@ -200,7 +200,7 @@ class PollEventHandle : public EventHandle {
   FileDescriptor fd_;
   int pending_actions_;
   PollPoller::HandlesList poller_handles_list_;
-  Scheduler* scheduler_;
+  ThreadPool* thread_pool_;
   std::shared_ptr<PollPoller> poller_;
   bool is_orphaned_;
   bool is_shutdown_;
@@ -293,7 +293,7 @@ int PollEventHandle::NotifyOnLocked(PosixEngineClosure** st,
                                     PosixEngineClosure* closure) {
   if (is_shutdown_ || pollhup_) {
     closure->SetStatus(shutdown_error_);
-    scheduler_->Run(closure);
+    thread_pool_->Run(closure);
   } else if (*st == reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)) {
     // not ready ==> switch to a waiting state by setting the closure
     *st = closure;
@@ -302,7 +302,7 @@ int PollEventHandle::NotifyOnLocked(PosixEngineClosure** st,
     // already ready ==> queue the closure to run immediately
     *st = reinterpret_cast<PosixEngineClosure*>(kClosureNotReady);
     closure->SetStatus(shutdown_error_);
-    scheduler_->Run(closure);
+    thread_pool_->Run(closure);
     return 1;
   } else {
     // upcallptr was set to a different closure.  This is an error!
@@ -327,7 +327,7 @@ int PollEventHandle::SetReadyLocked(PosixEngineClosure** st) {
     PosixEngineClosure* closure = *st;
     *st = reinterpret_cast<PosixEngineClosure*>(kClosureNotReady);
     closure->SetStatus(shutdown_error_);
-    scheduler_->Run(closure);
+    thread_pool_->Run(closure);
     return 1;
   }
 }
@@ -402,7 +402,7 @@ void PollEventHandle::NotifyOnError(PosixEngineClosure* on_error) {
   on_error->SetStatus(
       absl::Status(absl::StatusCode::kCancelled,
                    "Polling engine does not support tracking errors"));
-  scheduler_->Run(on_error);
+  thread_pool_->Run(on_error);
 }
 
 void PollEventHandle::SetReadable() {
@@ -503,8 +503,9 @@ void PollPoller::PollerHandlesListRemoveHandle(PollEventHandle* handle) {
   --num_poll_handles_;
 }
 
-PollPoller::PollPoller(Scheduler* scheduler, bool use_phony_poll)
-    : scheduler_(scheduler),
+PollPoller::PollPoller(std::shared_ptr<ThreadPool> thread_pool,
+                       bool use_phony_poll)
+    : thread_pool_(std::move(thread_pool)),
       use_phony_poll_(use_phony_poll),
       was_kicked_(false),
       was_kicked_ext_(false),
@@ -752,12 +753,12 @@ void PollPoller::ResetKickState() {
   was_kicked_ext_ = false;
 }
 
-std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
-                                           bool use_phony_poll) {
+std::shared_ptr<PollPoller> MakePollPoller(
+    std::shared_ptr<ThreadPool> thread_pool, bool use_phony_poll) {
   static bool kPollPollerSupported =
       grpc_event_engine::experimental::SupportsWakeupFd();
   if (kPollPollerSupported) {
-    return std::make_shared<PollPoller>(scheduler, use_phony_poll);
+    return std::make_shared<PollPoller>(std::move(thread_pool), use_phony_poll);
   }
   return nullptr;
 }
@@ -788,8 +789,8 @@ void PollPoller::Kick() { grpc_core::Crash("unimplemented"); }
 
 // If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
 // nullptr.
-std::shared_ptr<PollPoller> MakePollPoller(Scheduler* /*scheduler*/,
-                                           bool /* use_phony_poll */) {
+std::shared_ptr<PollPoller> MakePollPoller(
+    std::shared_ptr<ThreadPool> /*thread_pool*/, bool /* use_phony_poll */) {
   return nullptr;
 }
 

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

@@ -27,6 +27,7 @@
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_event_engine::experimental {
@@ -37,7 +38,8 @@ class PollEventHandle;
 class PollPoller : public PosixEventPoller,
                    public std::enable_shared_from_this<PollPoller> {
  public:
-  explicit PollPoller(Scheduler* scheduler, bool use_phony_poll = false);
+  explicit PollPoller(std::shared_ptr<ThreadPool> thread_pool,
+                      bool use_phony_poll = false);
   EventHandle* CreateHandle(FileDescriptor fd, absl::string_view name,
                             bool track_err) override;
   Poller::WorkResult Work(
@@ -45,7 +47,7 @@ class PollPoller : public PosixEventPoller,
       absl::FunctionRef<void()> schedule_poll_again) override;
   std::string Name() override { return "poll"; }
   void Kick() override;
-  Scheduler* GetScheduler() { return scheduler_; }
+  ThreadPool* GetThreadPool() { return thread_pool_.get(); }
   bool CanTrackErrors() const override { return false; }
   ~PollPoller() override;
 
@@ -71,7 +73,7 @@ class PollPoller : public PosixEventPoller,
     PollEventHandle* prev = nullptr;
   };
   grpc_core::Mutex mu_;
-  Scheduler* scheduler_;
+  std::shared_ptr<ThreadPool> thread_pool_;
   bool use_phony_poll_;
   bool was_kicked_ ABSL_GUARDED_BY(mu_);
   bool was_kicked_ext_ ABSL_GUARDED_BY(mu_);
@@ -85,8 +87,8 @@ class PollPoller : public PosixEventPoller,
 // It use_phony_poll is true, it implies that the poller is declared
 // non-polling and any attempt to schedule a blocking poll will result in a
 // crash failure.
-std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
-                                           bool use_phony_poll);
+std::shared_ptr<PollPoller> MakePollPoller(
+    std::shared_ptr<ThreadPool> thread_pool, bool use_phony_poll);
 
 }  // namespace grpc_event_engine::experimental
 

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

@@ -19,7 +19,6 @@
 
 #include <string>
 
-#include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "src/core/lib/event_engine/poller.h"
@@ -28,13 +27,6 @@
 
 namespace grpc_event_engine::experimental {
 
-class Scheduler {
- public:
-  virtual void Run(experimental::EventEngine::Closure* closure) = 0;
-  virtual void Run(absl::AnyInvocable<void()>) = 0;
-  virtual ~Scheduler() = default;
-};
-
 class PosixEventPoller;
 
 class EventHandle {

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

@@ -15,6 +15,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <utility>
 
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
@@ -34,22 +35,26 @@ bool PollStrategyMatches(absl::string_view strategy, absl::string_view want) {
 }
 }  // namespace
 
-std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler) {
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(
+    std::shared_ptr<ThreadPool> thread_pool) {
+  // Note that Make*Poller are allowed to return nullptr - e.g. MakeEpoll1Poller
+  // would return nullptr if an epoll poller is requested on unsupported
+  // platform.
   std::shared_ptr<PosixEventPoller> poller;
   auto strings =
       absl::StrSplit(grpc_core::ConfigVars::Get().PollStrategy(), ',');
   for (auto it = strings.begin(); it != strings.end() && poller == nullptr;
        it++) {
     if (PollStrategyMatches(*it, "epoll1")) {
-      poller = MakeEpoll1Poller(scheduler);
+      poller = MakeEpoll1Poller(thread_pool);
     }
     if (poller == nullptr && PollStrategyMatches(*it, "poll")) {
       // If epoll1 fails and if poll strategy matches "poll", use Poll poller
-      poller = MakePollPoller(scheduler, /*use_phony_poll=*/false);
+      poller = MakePollPoller(thread_pool, /*use_phony_poll=*/false);
     } else if (poller == nullptr && PollStrategyMatches(*it, "none")) {
       // If epoll1 fails and if poll strategy matches "none", use phony poll
       // poller.
-      poller = MakePollPoller(scheduler, /*use_phony_poll=*/true);
+      poller = MakePollPoller(thread_pool, /*use_phony_poll=*/true);
     }
   }
   return poller;
@@ -57,7 +62,8 @@ std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler) {
 
 #else  // GRPC_POSIX_SOCKET_TCP
 
-std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* /*scheduler*/) {
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(
+    std::shared_ptr<ThreadPool> /*thread_pool*/) {
   return nullptr;
 }
 

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

@@ -22,11 +22,12 @@
 namespace grpc_event_engine::experimental {
 
 class PosixEventPoller;
-class Scheduler;
+class ThreadPool;
 
 // Return an instance of an event poller which is tied to the specified
 // scheduler.
-std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler);
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(
+    std::shared_ptr<ThreadPool> thread_pool);
 
 }  // namespace grpc_event_engine::experimental
 

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

@@ -118,6 +118,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
       ares_socket_t as) override {
     grpc_core::MutexLock lock(&mu_);
     owned_fds_.insert(as);
+    CHECK_NE(poller_, nullptr);
     FileDescriptor fd(as, poller_->posix_interface().generation());
     return std::make_unique<GrpcPolledFdPosix>(
         as,

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

@@ -117,7 +117,7 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
         if (state_.compare_exchange_strong(curr, kClosureNotReady,
                                            std::memory_order_acq_rel,
                                            std::memory_order_acquire)) {
-          scheduler_->Run(closure);
+          thread_pool_->Run(closure);
           return;  // Successful. Return.
         }
         break;  // retry
@@ -131,7 +131,7 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
           absl::Status shutdown_err =
               grpc_core::internal::StatusGetFromHeapPtr(curr & ~kShutdownBit);
           closure->SetStatus(shutdown_err);
-          scheduler_->Run(closure);
+          thread_pool_->Run(closure);
           return;
         }
 
@@ -187,7 +187,7 @@ bool LockfreeEvent::SetShutdown(absl::Status shutdown_error) {
                                            std::memory_order_acquire)) {
           auto closure = reinterpret_cast<PosixEngineClosure*>(curr);
           closure->SetStatus(shutdown_error);
-          scheduler_->Run(closure);
+          thread_pool_->Run(closure);
           return true;
         }
         // 'curr' was a closure but now changed to a different state. We will
@@ -234,7 +234,7 @@ void LockfreeEvent::SetReady() {
           // notify_on (or set_shutdown)
           auto closure = reinterpret_cast<PosixEngineClosure*>(curr);
           closure->SetStatus(absl::OkStatus());
-          scheduler_->Run(closure);
+          thread_pool_->Run(closure);
           return;
         }
         // else the state changed again (only possible by either a racing

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

@@ -21,14 +21,13 @@
 
 #include "absl/status/status.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 
 namespace grpc_event_engine::experimental {
 
-class Scheduler;
-
 class LockfreeEvent {
  public:
-  explicit LockfreeEvent(Scheduler* scheduler) : scheduler_(scheduler) {}
+  explicit LockfreeEvent(ThreadPool* thread_pool) : thread_pool_(thread_pool) {}
 
   LockfreeEvent(const LockfreeEvent&) = delete;
   LockfreeEvent& operator=(const LockfreeEvent&) = delete;
@@ -62,7 +61,7 @@ class LockfreeEvent {
   enum State { kClosureNotReady = 0, kClosureReady = 2, kShutdownBit = 1 };
 
   std::atomic<intptr_t> state_;
-  Scheduler* scheduler_;
+  ThreadPool* thread_pool_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -99,7 +99,7 @@ PosixErrorOr<int64_t> TcpSend(EventEnginePosixInterface* posix_interface,
                               const FileDescriptor& fd,
                               const struct msghdr* msg, int* saved_errno,
                               int additional_flags = 0) {
-  GRPC_LATENT_SEE_PARENT_SCOPE("TcpSend");
+  GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("TcpSend");
   PosixErrorOr<int64_t> send_result;
   do {
     grpc_core::global_stats().IncrementSyscallWrite();
@@ -290,7 +290,7 @@ absl::Status PosixEndpointImpl::TcpAnnotateError(absl::Status src_error) const {
 
 // Returns true if data available to read or error other than EAGAIN.
 bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
-  GRPC_LATENT_SEE_INNER_SCOPE("TcpDoRead");
+  GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("TcpDoRead");
 
   struct msghdr msg;
   struct iovec iov[MAX_READ_IOVEC];