grpc 1.55.0 → 1.58.0

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h

@@ -0,0 +1,223 @@
+//
+//
+// Copyright 2015 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_THREAD_POOL_WORK_STEALING_THREAD_POOL_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_WORK_STEALING_THREAD_POOL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <atomic>
+#include <memory>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/event_engine/thread_pool/thread_count.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
+#include "src/core/lib/event_engine/work_queue/basic_work_queue.h"
+#include "src/core/lib/event_engine/work_queue/work_queue.h"
+#include "src/core/lib/gprpp/notification.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class WorkStealingThreadPool final : public ThreadPool {
+ public:
+  explicit WorkStealingThreadPool(size_t reserve_threads);
+  // Asserts Quiesce was called.
+  ~WorkStealingThreadPool() override;
+  // Shut down the pool, and wait for all threads to exit.
+  // This method is safe to call from within a ThreadPool thread.
+  void Quiesce() override;
+  // Run must not be called after Quiesce completes
+  void Run(absl::AnyInvocable<void()> callback) override;
+  void Run(EventEngine::Closure* closure) override;
+
+  // Forkable
+  // These methods are exposed on the public object to allow for testing.
+  void PrepareFork() override;
+  void PostforkParent() override;
+  void PostforkChild() override;
+
+ private:
+  // A basic communication mechanism to signal waiting threads that work is
+  // available.
+  class WorkSignal {
+   public:
+    void Signal();
+    void SignalAll();
+    // Returns whether a timeout occurred.
+    bool WaitWithTimeout(grpc_core::Duration time);
+
+   private:
+    grpc_core::Mutex mu_;
+    grpc_core::CondVar cv_ ABSL_GUARDED_BY(mu_);
+  };
+
+  // A pool of WorkQueues that participate in work stealing.
+  //
+  // Every worker thread registers and unregisters its thread-local thread pool
+  // here, and steals closures from other threads when work is otherwise
+  // unavailable.
+  class TheftRegistry {
+   public:
+    // Allow any member of the registry to steal from the provided queue.
+    void Enroll(WorkQueue* queue) ABSL_LOCKS_EXCLUDED(mu_);
+    // Disallow work stealing from the provided queue.
+    void Unenroll(WorkQueue* queue) ABSL_LOCKS_EXCLUDED(mu_);
+    // Returns one closure from another thread, or nullptr if none are
+    // available.
+    EventEngine::Closure* StealOne() ABSL_LOCKS_EXCLUDED(mu_);
+
+   private:
+    grpc_core::Mutex mu_;
+    absl::flat_hash_set<WorkQueue*> queues_ ABSL_GUARDED_BY(mu_);
+  };
+
+  // An implementation of the ThreadPool
+  // This object is held as a shared_ptr between the owning ThreadPool and each
+  // worker thread. This design allows a ThreadPool worker thread to be the last
+  // owner of the ThreadPool itself.
+  class WorkStealingThreadPoolImpl
+      : public std::enable_shared_from_this<WorkStealingThreadPoolImpl> {
+   public:
+    explicit WorkStealingThreadPoolImpl(size_t reserve_threads);
+    // Start all threads.
+    void Start();
+    // Add a closure to a work queue, preferably a thread-local queue if
+    // available, otherwise the global queue.
+    void Run(EventEngine::Closure* closure);
+    // Start a new thread.
+    // The reason argument determines whether thread creation is rate-limited;
+    // threads created to populate the initial pool are not rate-limited, but
+    // all others thread creation scenarios are rate-limited.
+    void StartThread();
+    // Shut down the pool, and wait for all threads to exit.
+    // This method is safe to call from within a ThreadPool thread.
+    void Quiesce();
+    // Sets a throttled state.
+    // After the initial pool has been created, if the pool is backlogged when
+    // a new thread has started, it is rate limited.
+    // Returns the previous throttling state.
+    bool SetThrottled(bool throttle);
+    // Set the shutdown flag.
+    void SetShutdown(bool is_shutdown);
+    // Set the forking flag.
+    void SetForking(bool is_forking);
+    // Forkable
+    // Ensures that the thread pool is empty before forking.
+    // Postfork parent and child have the same behavior.
+    void PrepareFork();
+    void Postfork();
+    // Accessor methods
+    bool IsShutdown();
+    bool IsForking();
+    bool IsQuiesced();
+    size_t reserve_threads() { return reserve_threads_; }
+    BusyThreadCount* busy_thread_count() { return &busy_thread_count_; }
+    LivingThreadCount* living_thread_count() { return &living_thread_count_; }
+    TheftRegistry* theft_registry() { return &theft_registry_; }
+    WorkQueue* queue() { return &queue_; }
+    WorkSignal* work_signal() { return &work_signal_; }
+
+   private:
+    // Lifeguard monitors the pool and keeps it healthy.
+    // It has two main responsibilities:
+    //  * scale the pool to match demand.
+    //  * distribute work to worker threads if the global queue is backing up
+    //    and there are threads that can accept work.
+    class Lifeguard {
+     public:
+      explicit Lifeguard(WorkStealingThreadPoolImpl* pool);
+      // Start the lifeguard thread.
+      void Start();
+      // Block until the lifeguard thread is shut down.
+      // Afterwards, reset the lifeguard state so it can start again cleanly.
+      void BlockUntilShutdownAndReset();
+
+     private:
+      // The main body of the lifeguard thread.
+      void LifeguardMain();
+      // Starts a new thread if the pool is backlogged
+      void MaybeStartNewThread();
+
+      WorkStealingThreadPoolImpl* pool_;
+      grpc_core::BackOff backoff_;
+      // Used for signaling that the lifeguard thread has stopped running.
+      std::unique_ptr<grpc_core::Notification> lifeguard_should_shut_down_;
+      std::unique_ptr<grpc_core::Notification> lifeguard_is_shut_down_;
+      std::atomic<bool> lifeguard_running_{false};
+    };
+
+    const size_t reserve_threads_;
+    BusyThreadCount busy_thread_count_;
+    LivingThreadCount living_thread_count_;
+    TheftRegistry theft_registry_;
+    BasicWorkQueue queue_;
+    // Track shutdown and fork bits separately.
+    // It's possible for a ThreadPool to initiate shut down while fork handlers
+    // are running, and similarly possible for a fork event to occur during
+    // shutdown.
+    std::atomic<bool> shutdown_{false};
+    std::atomic<bool> forking_{false};
+    std::atomic<bool> quiesced_{false};
+    std::atomic<uint64_t> last_started_thread_{0};
+    // After pool creation we use this to rate limit creation of threads to one
+    // at a time.
+    std::atomic<bool> throttled_{false};
+    WorkSignal work_signal_;
+    Lifeguard lifeguard_;
+  };
+
+  class ThreadState {
+   public:
+    explicit ThreadState(std::shared_ptr<WorkStealingThreadPoolImpl> pool);
+    void ThreadBody();
+    void SleepIfRunning();
+    bool Step();
+    // After the pool is shut down, ensure all local and global callbacks are
+    // executed before quitting the thread.
+    void FinishDraining();
+
+   private:
+    // pool_ must be the first member so that it is alive when the thread count
+    // is decremented at time of destruction. This is necessary when this thread
+    // state holds the last shared_ptr keeping the pool alive.
+    std::shared_ptr<WorkStealingThreadPoolImpl> pool_;
+    // auto_thread_counter_ must be declared after pool_, so that the thread
+    // count is decremented after all other pool state is cleaned up.
+    LivingThreadCount::AutoThreadCounter auto_thread_counter_;
+    grpc_core::BackOff backoff_;
+    size_t busy_count_idx_;
+  };
+
+  const std::shared_ptr<WorkStealingThreadPoolImpl> pool_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_WORK_STEALING_THREAD_POOL_H

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

@@ -0,0 +1,157 @@
+// Copyright 2023 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/event_engine/thready_event_engine/thready_event_engine.h"
+
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/thd.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+void ThreadyEventEngine::Asynchronously(absl::AnyInvocable<void()> fn) {
+  grpc_core::Thread t("thready_event_engine", std::move(fn), nullptr,
+                      grpc_core::Thread::Options().set_joinable(false));
+  t.Start();
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+ThreadyEventEngine::CreateListener(
+    Listener::AcceptCallback on_accept,
+    absl::AnyInvocable<void(absl::Status)> on_shutdown,
+    const EndpointConfig& config,
+    std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
+  return impl_->CreateListener(
+      [this, on_accept = std::make_shared<Listener::AcceptCallback>(
+                 std::move(on_accept))](std::unique_ptr<Endpoint> endpoint,
+                                        MemoryAllocator memory_allocator) {
+        Asynchronously(
+            [on_accept, endpoint = std::move(endpoint),
+             memory_allocator = std::move(memory_allocator)]() mutable {
+              (*on_accept)(std::move(endpoint), std::move(memory_allocator));
+            });
+      },
+      [this,
+       on_shutdown = std::move(on_shutdown)](absl::Status status) mutable {
+        Asynchronously([on_shutdown = std::move(on_shutdown),
+                        status = std::move(status)]() mutable {
+          on_shutdown(std::move(status));
+        });
+      },
+      config, std::move(memory_allocator_factory));
+}
+
+EventEngine::ConnectionHandle ThreadyEventEngine::Connect(
+    OnConnectCallback on_connect, const ResolvedAddress& addr,
+    const EndpointConfig& args, MemoryAllocator memory_allocator,
+    Duration timeout) {
+  return impl_->Connect(
+      [this, on_connect = std::move(on_connect)](
+          absl::StatusOr<std::unique_ptr<Endpoint>> c) mutable {
+        Asynchronously(
+            [on_connect = std::move(on_connect), c = std::move(c)]() mutable {
+              on_connect(std::move(c));
+            });
+      },
+      addr, args, std::move(memory_allocator), timeout);
+}
+
+bool ThreadyEventEngine::CancelConnect(ConnectionHandle handle) {
+  return impl_->CancelConnect(handle);
+}
+
+bool ThreadyEventEngine::IsWorkerThread() {
+  grpc_core::Crash("we should remove this");
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+ThreadyEventEngine::GetDNSResolver(
+    const DNSResolver::ResolverOptions& options) {
+  return std::make_unique<ThreadyDNSResolver>(*impl_->GetDNSResolver(options));
+}
+
+void ThreadyEventEngine::Run(Closure* closure) {
+  Run([closure]() { closure->Run(); });
+}
+
+void ThreadyEventEngine::Run(absl::AnyInvocable<void()> closure) {
+  Asynchronously(std::move(closure));
+}
+
+EventEngine::TaskHandle ThreadyEventEngine::RunAfter(Duration when,
+                                                     Closure* closure) {
+  return RunAfter(when, [closure]() { closure->Run(); });
+}
+
+EventEngine::TaskHandle ThreadyEventEngine::RunAfter(
+    Duration when, absl::AnyInvocable<void()> closure) {
+  return impl_->RunAfter(when, [this, closure = std::move(closure)]() mutable {
+    Asynchronously(std::move(closure));
+  });
+}
+
+bool ThreadyEventEngine::Cancel(TaskHandle handle) {
+  return impl_->Cancel(handle);
+}
+
+void ThreadyEventEngine::ThreadyDNSResolver::LookupHostname(
+    LookupHostnameCallback on_resolve, absl::string_view name,
+    absl::string_view default_port) {
+  return impl_->LookupHostname(
+      [this, on_resolve = std::move(on_resolve)](
+          absl::StatusOr<std::vector<ResolvedAddress>> addresses) mutable {
+        engine_->Asynchronously([on_resolve = std::move(on_resolve),
+                                 addresses = std::move(addresses)]() mutable {
+          on_resolve(std::move(addresses));
+        });
+      },
+      name, default_port);
+}
+
+void ThreadyEventEngine::ThreadyDNSResolver::LookupSRV(
+    LookupSRVCallback on_resolve, absl::string_view name) {
+  return impl_->LookupSRV(
+      [this, on_resolve = std::move(on_resolve)](
+          absl::StatusOr<std::vector<SRVRecord>> records) mutable {
+        return engine_->Asynchronously(
+            [on_resolve = std::move(on_resolve),
+             records = std::move(records)]() mutable {
+              on_resolve(std::move(records));
+            });
+      },
+      name);
+}
+
+void ThreadyEventEngine::ThreadyDNSResolver::LookupTXT(
+    LookupTXTCallback on_resolve, absl::string_view name) {
+  return impl_->LookupTXT(
+      [this, on_resolve = std::move(on_resolve)](
+          absl::StatusOr<std::vector<std::string>> record) mutable {
+        return engine_->Asynchronously([on_resolve = std::move(on_resolve),
+                                        record = std::move(record)]() mutable {
+          on_resolve(std::move(record));
+        });
+      },
+      name);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,104 @@
+// Copyright 2023 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_THREADY_EVENT_ENGINE_THREADY_EVENT_ENGINE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREADY_EVENT_ENGINE_THREADY_EVENT_ENGINE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// An EventEngine that spawns a thread at every available opportunity:
+// - Run() spawns a thread
+// - RunAfter() schedules a timer that spawns a thread to run the callback
+// - Endpoint operations spawn threads and then call the underlying event engine
+//   functions
+// Implemented as a decorator around a complete EventEngine so that it need not
+// deal with OS details.
+// This event engine is intended to be used for testing with TSAN to maximize
+// its visibility into race conditions in the calling code.
+class ThreadyEventEngine final : public EventEngine {
+ public:
+  explicit ThreadyEventEngine(std::shared_ptr<EventEngine> impl)
+      : impl_(std::move(impl)) {}
+
+  absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+      Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      override;
+
+  ConnectionHandle Connect(OnConnectCallback on_connect,
+                           const ResolvedAddress& addr,
+                           const EndpointConfig& args,
+                           MemoryAllocator memory_allocator,
+                           Duration timeout) override;
+
+  bool CancelConnect(ConnectionHandle handle) override;
+
+  bool IsWorkerThread() override;
+
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) override;
+
+  void Run(Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+
+  TaskHandle RunAfter(Duration when, Closure* closure) override;
+  TaskHandle RunAfter(Duration when,
+                      absl::AnyInvocable<void()> closure) override;
+
+  bool Cancel(TaskHandle handle) override;
+
+ private:
+  class ThreadyDNSResolver final : public DNSResolver {
+   public:
+    explicit ThreadyDNSResolver(std::unique_ptr<DNSResolver> impl)
+        : impl_(std::move(impl)) {}
+    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;
+
+   private:
+    std::unique_ptr<DNSResolver> impl_;
+    ThreadyEventEngine* engine_;
+  };
+
+  void Asynchronously(absl::AnyInvocable<void()> fn);
+
+  std::shared_ptr<EventEngine> impl_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREADY_EVENT_ENGINE_THREADY_EVENT_ENGINE_H

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

@@ -22,6 +22,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
@@ -32,8 +33,8 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-IOCP::IOCP(Executor* executor) noexcept
-    : executor_(executor),
+IOCP::IOCP(ThreadPool* thread_pool) noexcept
+    : thread_pool_(thread_pool),
       iocp_handle_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr,
                                           (ULONG_PTR) nullptr, 0)) {
   GPR_ASSERT(iocp_handle_);
@@ -44,7 +45,7 @@ IOCP::IOCP(Executor* executor) noexcept
 IOCP::~IOCP() {}
 
 std::unique_ptr<WinSocket> IOCP::Watch(SOCKET socket) {
-  auto wrapped_socket = std::make_unique<WinSocket>(socket, executor_);
+  auto wrapped_socket = std::make_unique<WinSocket>(socket, thread_pool_);
   HANDLE ret = CreateIoCompletionPort(
       reinterpret_cast<HANDLE>(socket), iocp_handle_,
       reinterpret_cast<uintptr_t>(wrapped_socket.get()), 0);

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

@@ -22,8 +22,8 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/executor/executor.h"
 #include "src/core/lib/event_engine/poller.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 {
@@ -31,7 +31,7 @@ namespace experimental {
 
 class IOCP final : public Poller {
  public:
-  explicit IOCP(Executor* executor) noexcept;
+  explicit IOCP(ThreadPool* thread_pool) noexcept;
   ~IOCP();
   // Not copyable
   IOCP(const IOCP&) = delete;
@@ -54,7 +54,7 @@ class IOCP final : public Poller {
   // Initialize default flags via checking platform support
   static DWORD WSASocketFlagsInit();
 
-  Executor* executor_;
+  ThreadPool* thread_pool_;
   HANDLE iocp_handle_;
   OVERLAPPED kick_overlap_;
   ULONG kick_token_;

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

@@ -17,8 +17,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 
-#include "src/core/lib/event_engine/executor/executor.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/win_socket.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -38,9 +38,9 @@ namespace experimental {
 
 // ---- WinSocket ----
 
-WinSocket::WinSocket(SOCKET socket, Executor* executor) noexcept
+WinSocket::WinSocket(SOCKET socket, ThreadPool* thread_pool) noexcept
     : socket_(socket),
-      executor_(executor),
+      thread_pool_(thread_pool),
       read_info_(this),
       write_info_(this) {}
 
@@ -90,11 +90,11 @@ void WinSocket::Shutdown(const grpc_core::DebugLocation& location,
 void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
   if (IsShutdown()) {
     info.SetError(WSAESHUTDOWN);
-    executor_->Run(closure);
+    thread_pool_->Run(closure);
     return;
   };
   if (std::exchange(info.has_pending_iocp_, false)) {
-    executor_->Run(closure);
+    thread_pool_->Run(closure);
   } else {
     EventEngine::Closure* prev = nullptr;
     GPR_ASSERT(info.closure_.compare_exchange_strong(prev, closure));
@@ -120,7 +120,7 @@ void WinSocket::OpState::SetReady() {
   GPR_ASSERT(!has_pending_iocp_);
   auto* closure = closure_.exchange(nullptr);
   if (closure) {
-    win_socket_->executor_->Run(closure);
+    win_socket_->thread_pool_->Run(closure);
   } else {
     has_pending_iocp_ = true;
   }

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

@@ -23,7 +23,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/executor/executor.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
 
@@ -43,7 +43,7 @@ class WinSocket {
     explicit OpState(WinSocket* win_socket) noexcept;
     // Signal a result has returned
     // If a callback is already primed for notification, it will be executed via
-    // the WinSocket's Executor. Otherwise, a "pending iocp" flag will
+    // the WinSocket's ThreadPool. Otherwise, a "pending iocp" flag will
     // be set.
     void SetReady();
     // Set error results for a completed op
@@ -72,7 +72,7 @@ class WinSocket {
     OverlappedResult result_;
   };
 
-  WinSocket(SOCKET socket, Executor* executor) noexcept;
+  WinSocket(SOCKET socket, ThreadPool* thread_pool) noexcept;
   ~WinSocket();
   // Calling NotifyOnRead means either of two things:
   //  - The IOCP already completed in the background, and we need to call
@@ -104,7 +104,7 @@ class WinSocket {
 
   SOCKET socket_;
   std::atomic<bool> is_shutdown_{false};
-  Executor* executor_;
+  ThreadPool* thread_pool_;
   // These OpStates are effectively synchronized using their respective
   // OVERLAPPED structures and the Overlapped I/O APIs. For example, OpState
   // users should not attempt to read their bytes_transeferred until