grpc 1.54.3 → 1.59.2

data/src/core/lib/event_engine/windows/windows_endpoint.cc

@@ -24,6 +24,7 @@
 #include <grpc/support/log_windows.h>
 
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -50,13 +51,12 @@ void DumpSliceBuffer(SliceBuffer* buffer, absl::string_view context_string) {
 WindowsEndpoint::WindowsEndpoint(
     const EventEngine::ResolvedAddress& peer_address,
     std::unique_ptr<WinSocket> socket, MemoryAllocator&& allocator,
-    const EndpointConfig& /* config */, Executor* executor,
+    const EndpointConfig& /* config */, ThreadPool* thread_pool,
     std::shared_ptr<EventEngine> engine)
     : peer_address_(peer_address),
       allocator_(std::move(allocator)),
-      executor_(executor),
-      io_state_(std::make_shared<AsyncIOState>(this, std::move(socket),
-                                               std::move(engine))) {
+      io_state_(std::make_shared<AsyncIOState>(
+          this, std::move(socket), std::move(engine), thread_pool)) {
   char addr[EventEngine::ResolvedAddress::MAX_SIZE_BYTES];
   int addr_len = sizeof(addr);
   if (getsockname(io_state_->socket->raw_socket(),
@@ -76,9 +76,9 @@ WindowsEndpoint::~WindowsEndpoint() {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("~WindowsEndpoint::%p", this);
 }
 
-absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", this);
-  if (io_state_->socket->IsShutdown()) {
+absl::Status WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", endpoint);
+  if (socket->IsShutdown()) {
     return absl::UnavailableError("Socket is shutting down.");
   }
   // Prepare the WSABUF struct
@@ -93,25 +93,25 @@ absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
   DWORD flags = 0;
   // First try a synchronous, non-blocking read.
   int status =
-      WSARecv(io_state_->socket->raw_socket(), wsa_buffers,
-              (DWORD)buffer->Count(), &bytes_read, &flags, nullptr, nullptr);
+      WSARecv(socket->raw_socket(), wsa_buffers, (DWORD)buffer->Count(),
+              &bytes_read, &flags, nullptr, nullptr);
   int wsa_error = status == 0 ? 0 : WSAGetLastError();
   if (wsa_error != WSAEWOULDBLOCK) {
     // Data or some error was returned immediately.
-    io_state_->socket->read_info()->SetResult(
+    socket->read_info()->SetResult(
         {/*wsa_error=*/wsa_error, /*bytes_read=*/bytes_read});
-    executor_->Run(&io_state_->handle_read_event);
+    thread_pool->Run(&handle_read_event);
     return absl::OkStatus();
   }
   // If the endpoint has already received some data, and the next call would
   // block, return the data in case that is all the data the reader expects.
-  if (io_state_->handle_read_event.MaybeFinishIfDataHasAlreadyBeenRead()) {
+  if (handle_read_event.MaybeFinishIfDataHasAlreadyBeenRead()) {
     return absl::OkStatus();
   }
   // Otherwise, let's retry, by queuing a read.
-  status = WSARecv(io_state_->socket->raw_socket(), wsa_buffers,
-                   (DWORD)buffer->Count(), &bytes_read, &flags,
-                   io_state_->socket->read_info()->overlapped(), nullptr);
+  status =
+      WSARecv(socket->raw_socket(), wsa_buffers, (DWORD)buffer->Count(),
+              &bytes_read, &flags, socket->read_info()->overlapped(), nullptr);
   wsa_error = status == 0 ? 0 : WSAGetLastError();
   if (wsa_error != 0 && wsa_error != WSA_IO_PENDING) {
     // Async read returned immediately with an error
@@ -119,14 +119,14 @@ absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
         wsa_error,
         absl::StrFormat("WindowsEndpont::%p Read failed", this).c_str());
   }
-  io_state_->socket->NotifyOnRead(&io_state_->handle_read_event);
+  socket->NotifyOnRead(&handle_read_event);
   return absl::OkStatus();
 }
 
 bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                            SliceBuffer* buffer, const ReadArgs* /* args */) {
   if (io_state_->socket->IsShutdown()) {
-    executor_->Run([on_read = std::move(on_read)]() mutable {
+    io_state_->thread_pool->Run([on_read = std::move(on_read)]() mutable {
       on_read(absl::UnavailableError("Socket is shutting down."));
     });
     return false;
@@ -140,12 +140,12 @@ bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
     buffer->AppendIndexed(Slice(allocator_.MakeSlice(min_read_size)));
   }
   io_state_->handle_read_event.Prime(io_state_, buffer, std::move(on_read));
-  auto status = DoTcpRead(buffer);
+  auto status = io_state_->DoTcpRead(buffer);
   if (!status.ok()) {
     // The read could not be completed.
-    io_state_->endpoint->executor_->Run([this, status]() {
-      io_state_->handle_read_event.ExecuteCallbackAndReset(status);
-    });
+    io_state_->thread_pool->Run(
+        [cb = io_state_->handle_read_event.ResetAndReturnCallback(),
+         status]() mutable { cb(status); });
   }
   return false;
 }
@@ -154,9 +154,10 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
                             SliceBuffer* data, const WriteArgs* /* args */) {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p writing", this);
   if (io_state_->socket->IsShutdown()) {
-    executor_->Run([on_writable = std::move(on_writable)]() mutable {
-      on_writable(absl::UnavailableError("Socket is shutting down."));
-    });
+    io_state_->thread_pool->Run(
+        [on_writable = std::move(on_writable)]() mutable {
+          on_writable(absl::UnavailableError("Socket is shutting down."));
+        });
     return false;
   }
   if (grpc_event_engine_endpoint_data_trace.enabled()) {
@@ -182,7 +183,7 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   if (status == 0) {
     if (bytes_sent == data->Length()) {
       // Write completed, exiting early
-      executor_->Run(
+      io_state_->thread_pool->Run(
           [cb = std::move(on_writable)]() mutable { cb(absl::OkStatus()); });
       return false;
     }
@@ -203,9 +204,10 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
     // then we can avoid doing an async write operation at all.
     int wsa_error = WSAGetLastError();
     if (wsa_error != WSAEWOULDBLOCK) {
-      executor_->Run([cb = std::move(on_writable), wsa_error]() mutable {
-        cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
-      });
+      io_state_->thread_pool->Run(
+          [cb = std::move(on_writable), wsa_error]() mutable {
+            cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
+          });
       return false;
     }
   }
@@ -217,9 +219,10 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   if (status != 0) {
     int wsa_error = WSAGetLastError();
     if (wsa_error != WSA_IO_PENDING) {
-      executor_->Run([cb = std::move(on_writable), wsa_error]() mutable {
-        cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
-      });
+      io_state_->thread_pool->Run(
+          [cb = std::move(on_writable), wsa_error]() mutable {
+            cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
+          });
       return false;
     }
   }
@@ -245,16 +248,22 @@ void AbortOnEvent(absl::Status) {
 }
 }  // namespace
 
-void WindowsEndpoint::HandleReadClosure::Reset() {
-  io_state_.reset();
+absl::AnyInvocable<void(absl::Status)>
+WindowsEndpoint::HandleReadClosure::ResetAndReturnCallback() {
+  auto cb = std::move(cb_);
   cb_ = &AbortOnEvent;
   buffer_ = nullptr;
+  io_state_.reset();
+  return cb;
 }
 
-void WindowsEndpoint::HandleWriteClosure::Reset() {
-  io_state_.reset();
+absl::AnyInvocable<void(absl::Status)>
+WindowsEndpoint::HandleWriteClosure::ResetAndReturnCallback() {
+  auto cb = std::move(cb_);
   cb_ = &AbortOnEvent;
   buffer_ = nullptr;
+  io_state_.reset();
+  return cb;
 }
 
 void WindowsEndpoint::HandleReadClosure::Prime(
@@ -275,6 +284,7 @@ void WindowsEndpoint::HandleWriteClosure::Prime(
 
 void WindowsEndpoint::HandleReadClosure::Run() {
   // Deletes the shared_ptr when this closure returns
+  // Note that the endpoint may have already been destroyed.
   auto io_state = std::move(io_state_);
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Read Event",
                                    io_state->endpoint);
@@ -283,21 +293,19 @@ void WindowsEndpoint::HandleReadClosure::Run() {
   if (result.wsa_error != 0) {
     status = GRPC_WSA_ERROR(result.wsa_error, "Async Read Error");
     buffer_->Clear();
-    return ExecuteCallbackAndReset(status);
+    return ResetAndReturnCallback()(status);
   }
   if (result.bytes_transferred == 0) {
     // Either the endpoint is shut down or we've seen the end of the stream
     if (grpc_event_engine_endpoint_data_trace.enabled()) {
-      DumpSliceBuffer(
-          buffer_, absl::StrFormat("WindowsEndpoint::%p READ (peer=%s)",
-                                   io_state->endpoint,
-                                   io_state->endpoint->peer_address_string_));
+      DumpSliceBuffer(buffer_, absl::StrFormat("WindowsEndpoint::%p READ",
+                                               io_state->endpoint));
     }
     status = absl::UnavailableError("End of TCP stream");
     grpc_core::StatusSetInt(&status, grpc_core::StatusIntProperty::kRpcStatus,
                             GRPC_STATUS_UNAVAILABLE);
     buffer_->Swap(last_read_buffer_);
-    return ExecuteCallbackAndReset(status);
+    return ResetAndReturnCallback()(status);
   }
   GPR_DEBUG_ASSERT(result.bytes_transferred > 0);
   GPR_DEBUG_ASSERT(result.bytes_transferred <= buffer_->Length());
@@ -305,34 +313,27 @@ void WindowsEndpoint::HandleReadClosure::Run() {
                                           last_read_buffer_);
   if (buffer_->Length() == 0) {
     buffer_->Swap(last_read_buffer_);
-    return ExecuteCallbackAndReset(status);
+    return ResetAndReturnCallback()(status);
   }
   // Doing another read. Let's keep the AsyncIOState alive a bit longer.
   io_state_ = std::move(io_state);
-  status = io_state_->endpoint->DoTcpRead(buffer_);
+  status = io_state_->DoTcpRead(buffer_);
   if (!status.ok()) {
-    io_state_.reset();
-    ExecuteCallbackAndReset(status);
+    return ResetAndReturnCallback()(status);
   }
 }
 
 bool WindowsEndpoint::HandleReadClosure::MaybeFinishIfDataHasAlreadyBeenRead() {
   if (last_read_buffer_.Length() > 0) {
     buffer_->Swap(last_read_buffer_);
-    io_state_->endpoint->executor_->Run(
-        [this]() { ExecuteCallbackAndReset(absl::OkStatus()); });
+    // Captures io_state_ to ensure it remains alive until the callback is run.
+    io_state_->thread_pool->Run(
+        [cb = ResetAndReturnCallback()]() mutable { cb(absl::OkStatus()); });
     return true;
   }
   return false;
 }
 
-void WindowsEndpoint::HandleReadClosure::ExecuteCallbackAndReset(
-    absl::Status status) {
-  auto cb = std::move(cb_);
-  Reset();
-  cb(status);
-}
-
 void WindowsEndpoint::HandleReadClosure::DonateSpareSlices(
     SliceBuffer* buffer) {
   // Donee buffer must be empty.
@@ -347,7 +348,6 @@ void WindowsEndpoint::HandleWriteClosure::Run() {
   auto io_state = std::move(io_state_);
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Write Event",
                                    io_state->endpoint);
-  auto cb = std::move(cb_);
   const auto result = io_state->socket->write_info()->result();
   absl::Status status;
   if (result.wsa_error != 0) {
@@ -355,18 +355,19 @@ void WindowsEndpoint::HandleWriteClosure::Run() {
   } else {
     GPR_ASSERT(result.bytes_transferred == buffer_->Length());
   }
-  Reset();
-  cb(status);
+  return ResetAndReturnCallback()(status);
 }
 
 // ---- AsyncIOState ----
 
 WindowsEndpoint::AsyncIOState::AsyncIOState(WindowsEndpoint* endpoint,
                                             std::unique_ptr<WinSocket> socket,
-                                            std::shared_ptr<EventEngine> engine)
+                                            std::shared_ptr<EventEngine> engine,
+                                            ThreadPool* thread_pool)
     : endpoint(endpoint),
       socket(std::move(socket)),
-      engine(std::move(engine)) {}
+      engine(std::move(engine)),
+      thread_pool(thread_pool) {}
 
 WindowsEndpoint::AsyncIOState::~AsyncIOState() {
   socket->Shutdown(DEBUG_LOCATION, "~AsyncIOState");

data/src/core/lib/event_engine/windows/windows_endpoint.h

@@ -19,6 +19,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
 
 namespace grpc_event_engine {
@@ -29,7 +30,7 @@ class WindowsEndpoint : public EventEngine::Endpoint {
   WindowsEndpoint(const EventEngine::ResolvedAddress& peer_address,
                   std::unique_ptr<WinSocket> socket,
                   MemoryAllocator&& allocator, const EndpointConfig& config,
-                  Executor* Executor, std::shared_ptr<EventEngine> engine);
+                  ThreadPool* thread_pool, std::shared_ptr<EventEngine> engine);
   ~WindowsEndpoint() override;
   bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
             const ReadArgs* args) override;
@@ -47,15 +48,15 @@ class WindowsEndpoint : public EventEngine::Endpoint {
     void Run() override;
     void Prime(std::shared_ptr<AsyncIOState> io_state, SliceBuffer* buffer,
                absl::AnyInvocable<void(absl::Status)> cb);
-    // Resets the per-request data
-    void Reset();
+    // Resets the per-request data, releasing the ref on io_state_.
+    // Returns the previous callback.
+    ABSL_MUST_USE_RESULT absl::AnyInvocable<void(absl::Status)>
+    ResetAndReturnCallback();
     // Run the callback with whatever data is available, and reset state.
     //
     // Returns true if the callback has been called with some data. Returns
     // false if no data has been read.
     bool MaybeFinishIfDataHasAlreadyBeenRead();
-    // Execute the callback and reset.
-    void ExecuteCallbackAndReset(absl::Status status);
     // Swap any leftover slices into the provided buffer
     void DonateSpareSlices(SliceBuffer* buffer);
 
@@ -72,8 +73,10 @@ class WindowsEndpoint : public EventEngine::Endpoint {
     void Run() override;
     void Prime(std::shared_ptr<AsyncIOState> io_state, SliceBuffer* buffer,
                absl::AnyInvocable<void(absl::Status)> cb);
-    // Resets the per-request data
-    void Reset();
+    // Resets the per-request data, releasing the ref on io_state_.
+    // Returns the previous callback.
+    ABSL_MUST_USE_RESULT absl::AnyInvocable<void(absl::Status)>
+    ResetAndReturnCallback();
 
    private:
     std::shared_ptr<AsyncIOState> io_state_;
@@ -89,25 +92,26 @@ class WindowsEndpoint : public EventEngine::Endpoint {
   // events are complete.
   struct AsyncIOState {
     AsyncIOState(WindowsEndpoint* endpoint, std::unique_ptr<WinSocket> socket,
-                 std::shared_ptr<EventEngine> engine);
+                 std::shared_ptr<EventEngine> engine, ThreadPool* thread_pool);
     ~AsyncIOState();
+
+    // Perform the low-level calls and execute the HandleReadClosure
+    // asynchronously.
+    absl::Status DoTcpRead(SliceBuffer* buffer);
+
     WindowsEndpoint* const endpoint;
     std::unique_ptr<WinSocket> socket;
     HandleReadClosure handle_read_event;
     HandleWriteClosure handle_write_event;
     std::shared_ptr<EventEngine> engine;
+    ThreadPool* thread_pool;
   };
 
-  // Perform the low-level calls and execute the HandleReadClosure
-  // asynchronously.
-  absl::Status DoTcpRead(SliceBuffer* buffer);
-
   EventEngine::ResolvedAddress peer_address_;
   std::string peer_address_string_;
   EventEngine::ResolvedAddress local_address_;
   std::string local_address_string_;
   MemoryAllocator allocator_;
-  Executor* executor_;
   std::shared_ptr<AsyncIOState> io_state_;
 };
 

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -25,13 +25,14 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
+#include <grpc/support/cpu.h>
 
 #include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/event_engine/common_closures.h"
-#include "src/core/lib/event_engine/executor/executor.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
@@ -48,21 +49,21 @@ namespace experimental {
 
 // ---- IOCPWorkClosure ----
 
-WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(Executor* executor,
+WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(ThreadPool* thread_pool,
                                                      IOCP* iocp)
-    : executor_(executor), iocp_(iocp) {
-  executor_->Run(this);
+    : thread_pool_(thread_pool), iocp_(iocp) {
+  thread_pool_->Run(this);
 }
 
 void WindowsEventEngine::IOCPWorkClosure::Run() {
   auto result = iocp_->Work(std::chrono::seconds(60), [this] {
     workers_.fetch_add(1);
-    executor_->Run(this);
+    thread_pool_->Run(this);
   });
   if (result == Poller::WorkResult::kDeadlineExceeded) {
     // iocp received no messages. restart the worker
     workers_.fetch_add(1);
-    executor_->Run(this);
+    thread_pool_->Run(this);
   }
   if (workers_.fetch_sub(1) == 1) done_signal_.Notify();
 }
@@ -97,10 +98,11 @@ struct WindowsEventEngine::TimerClosure final : public EventEngine::Closure {
 };
 
 WindowsEventEngine::WindowsEventEngine()
-    : executor_(std::make_shared<ThreadPool>()),
-      iocp_(executor_.get()),
-      timer_manager_(executor_),
-      iocp_worker_(executor_.get(), &iocp_) {
+    : thread_pool_(
+          MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
+      iocp_(thread_pool_.get()),
+      timer_manager_(thread_pool_),
+      iocp_worker_(thread_pool_.get(), &iocp_) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
   GPR_ASSERT(status == 0);
@@ -140,7 +142,7 @@ WindowsEventEngine::~WindowsEventEngine() {
   iocp_.Shutdown();
   GPR_ASSERT(WSACleanup() == 0);
   timer_manager_.Shutdown();
-  executor_->Quiesce();
+  thread_pool_->Quiesce();
 }
 
 bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
@@ -167,11 +169,11 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfter(
 }
 
 void WindowsEventEngine::Run(absl::AnyInvocable<void()> closure) {
-  executor_->Run(std::move(closure));
+  thread_pool_->Run(std::move(closure));
 }
 
 void WindowsEventEngine::Run(EventEngine::Closure* closure) {
-  executor_->Run(closure);
+  thread_pool_->Run(closure);
 }
 
 EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
@@ -192,7 +194,8 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
   return handle;
 }
 
-std::unique_ptr<EventEngine::DNSResolver> WindowsEventEngine::GetDNSResolver(
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+WindowsEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
   grpc_core::Crash("unimplemented");
 }
@@ -219,12 +222,12 @@ void WindowsEventEngine::OnConnectCompleted(
       state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
       endpoint = GRPC_WSA_ERROR(overlapped_result.wsa_error, "ConnectEx");
     } else {
-      // This code should be running in an executor thread already, so the
+      // This code should be running in a thread pool thread already, so the
       // callback can be run directly.
       ChannelArgsEndpointConfig cfg;
       endpoint = std::make_unique<WindowsEndpoint>(
           state->address, std::move(state->socket), std::move(state->allocator),
-          cfg, executor_.get(), shared_from_this());
+          cfg, thread_pool_.get(), shared_from_this());
     }
   }
   cb(std::move(endpoint));
@@ -400,8 +403,8 @@ WindowsEventEngine::CreateListener(
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
   return std::make_unique<WindowsEventEngineListener>(
       &iocp_, std::move(on_accept), std::move(on_shutdown),
-      std::move(memory_allocator_factory), shared_from_this(), executor_.get(),
-      config);
+      std::move(memory_allocator_factory), shared_from_this(),
+      thread_pool_.get(), config);
 }
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/windows/windows_engine.h

@@ -30,7 +30,7 @@
 
 #include "src/core/lib/event_engine/handle_containers.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/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -48,17 +48,13 @@ class WindowsEventEngine : public EventEngine,
   class WindowsDNSResolver : public EventEngine::DNSResolver {
    public:
     ~WindowsDNSResolver() override;
-    LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
-                                    absl::string_view name,
-                                    absl::string_view default_port,
-                                    Duration timeout) override;
-    LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
-                               absl::string_view name,
-                               Duration timeout) override;
-    LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
-                               absl::string_view name,
-                               Duration timeout) override;
-    bool CancelLookup(LookupTaskHandle handle) override;
+    void LookupHostname(LookupHostnameCallback on_resolve,
+                        absl::string_view name,
+                        absl::string_view default_port) override;
+    void LookupSRV(LookupSRVCallback on_resolve,
+                   absl::string_view name) override;
+    void LookupTXT(LookupTXTCallback on_resolve,
+                   absl::string_view name) override;
   };
 
   WindowsEventEngine();
@@ -79,7 +75,7 @@ class WindowsEventEngine : public EventEngine,
 
   bool CancelConnect(ConnectionHandle handle) override;
   bool IsWorkerThread() override;
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;
@@ -88,11 +84,11 @@ class WindowsEventEngine : public EventEngine,
                       absl::AnyInvocable<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
 
-  // Retrieve the base executor.
+  // Retrieve the base ThreadPool.
   // This is public because most classes that know the concrete
   // WindowsEventEngine type are effectively friends.
   // Not intended for external use.
-  Executor* executor() { return executor_.get(); }
+  ThreadPool* thread_pool() { return thread_pool_.get(); }
   IOCP* poller() { return &iocp_; }
 
  private:
@@ -116,14 +112,14 @@ class WindowsEventEngine : public EventEngine,
   // A poll worker which schedules itself unless kicked
   class IOCPWorkClosure : public EventEngine::Closure {
    public:
-    explicit IOCPWorkClosure(Executor* executor, IOCP* iocp);
+    explicit IOCPWorkClosure(ThreadPool* thread_pool, IOCP* iocp);
     void Run() override;
     void WaitForShutdown();
 
    private:
     std::atomic<int> workers_{1};
     grpc_core::Notification done_signal_;
-    Executor* executor_;
+    ThreadPool* thread_pool_;
     IOCP* iocp_;
   };
 
@@ -150,7 +146,7 @@ class WindowsEventEngine : public EventEngine,
   ConnectionHandleSet known_connection_handles_ ABSL_GUARDED_BY(connection_mu_);
   std::atomic<intptr_t> aba_token_{0};
 
-  std::shared_ptr<ThreadPool> executor_;
+  std::shared_ptr<ThreadPool> thread_pool_;
   IOCP iocp_;
   TimerManager timer_manager_;
   IOCPWorkClosure iocp_worker_;

data/src/core/lib/event_engine/windows/windows_listener.cc

@@ -201,7 +201,7 @@ void WindowsEventEngineListener::SinglePortSocketListener::
       peer_address, listener_->iocp_->Watch(io_state_->accept_socket),
       listener_->memory_allocator_factory_->CreateMemoryAllocator(
           absl::StrFormat("listener endpoint %s", peer_name)),
-      listener_->config_, listener_->executor_, listener_->engine_);
+      listener_->config_, listener_->thread_pool_, listener_->engine_);
   listener_->accept_cb_(
       std::move(endpoint),
       listener_->memory_allocator_factory_->CreateMemoryAllocator(
@@ -265,12 +265,12 @@ WindowsEventEngineListener::WindowsEventEngineListener(
     IOCP* iocp, AcceptCallback accept_cb,
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory,
-    std::shared_ptr<EventEngine> engine, Executor* executor,
+    std::shared_ptr<EventEngine> engine, ThreadPool* thread_pool,
     const EndpointConfig& config)
     : iocp_(iocp),
       config_(config),
       engine_(std::move(engine)),
-      executor_(executor),
+      thread_pool_(thread_pool),
       memory_allocator_factory_(std::move(memory_allocator_factory)),
       accept_cb_(std::move(accept_cb)),
       on_shutdown_(std::move(on_shutdown)) {}

data/src/core/lib/event_engine/windows/windows_listener.h

@@ -27,6 +27,7 @@
 #include <grpc/event_engine/memory_allocator.h>
 
 #include "src/core/lib/event_engine/common_closures.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/gprpp/sync.h"
 
@@ -39,7 +40,7 @@ class WindowsEventEngineListener : public EventEngine::Listener {
       IOCP* iocp, AcceptCallback accept_cb,
       absl::AnyInvocable<void(absl::Status)> on_shutdown,
       std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory,
-      std::shared_ptr<EventEngine> engine, Executor* executor_,
+      std::shared_ptr<EventEngine> engine, ThreadPool* thread_pool_,
       const EndpointConfig& config);
   ~WindowsEventEngineListener() override;
   absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr) override;
@@ -136,7 +137,7 @@ class WindowsEventEngineListener : public EventEngine::Listener {
   IOCP* const iocp_;
   const EndpointConfig& config_;
   std::shared_ptr<EventEngine> engine_;
-  Executor* executor_;
+  ThreadPool* thread_pool_;
   const std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory_;
   AcceptCallback accept_cb_;
   absl::AnyInvocable<void(absl::Status)> on_shutdown_;