grpc 1.50.0 → 1.52.0.pre2

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

@@ -1,35 +1,37 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/thread_pool.h"
 
+#include <atomic>
 #include <memory>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/gprpp/time.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -37,27 +39,63 @@ namespace experimental {
 namespace {
 // TODO(drfloob): Remove this, and replace it with the WorkQueue* for the
 // current thread (with nullptr indicating not a threadpool thread).
-GPR_THREAD_LOCAL(bool) g_threadpool_thread;
+thread_local bool g_threadpool_thread;
 }  // namespace
 
-void ThreadPool::StartThread(StatePtr state, bool throttled) {
+void ThreadPool::StartThread(StatePtr state, StartThreadReason reason) {
   state->thread_count.Add();
+  const auto now = grpc_core::Timestamp::Now();
+  switch (reason) {
+    case StartThreadReason::kNoWaitersWhenScheduling: {
+      auto time_since_last_start =
+          now - grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
+                    state->last_started_thread.load(std::memory_order_relaxed));
+      if (time_since_last_start < grpc_core::Duration::Seconds(1)) {
+        state->thread_count.Remove();
+        return;
+      }
+    }
+      ABSL_FALLTHROUGH_INTENDED;
+    case StartThreadReason::kNoWaitersWhenFinishedStarting:
+      if (state->currently_starting_one_thread.exchange(
+              true, std::memory_order_relaxed)) {
+        state->thread_count.Remove();
+        return;
+      }
+      state->last_started_thread.store(now.milliseconds_after_process_epoch(),
+                                       std::memory_order_relaxed);
+      break;
+    case StartThreadReason::kInitialPool:
+      break;
+  }
   struct ThreadArg {
     StatePtr state;
-    bool throttled;
+    StartThreadReason reason;
   };
   grpc_core::Thread(
       "event_engine",
       [](void* arg) {
         std::unique_ptr<ThreadArg> a(static_cast<ThreadArg*>(arg));
         g_threadpool_thread = true;
-        if (a->throttled) {
-          GPR_ASSERT(a->state->currently_starting_one_thread.exchange(
-              false, std::memory_order_relaxed));
+        switch (a->reason) {
+          case StartThreadReason::kInitialPool:
+            break;
+          case StartThreadReason::kNoWaitersWhenFinishedStarting:
+            a->state->queue.SleepIfRunning();
+            ABSL_FALLTHROUGH_INTENDED;
+          case StartThreadReason::kNoWaitersWhenScheduling:
+            // Release throttling variable
+            GPR_ASSERT(a->state->currently_starting_one_thread.exchange(
+                false, std::memory_order_relaxed));
+            if (a->state->queue.IsBacklogged()) {
+              StartThread(a->state,
+                          StartThreadReason::kNoWaitersWhenFinishedStarting);
+            }
+            break;
         }
         ThreadFunc(a->state);
       },
-      new ThreadArg{state, throttled}, nullptr,
+      new ThreadArg{state, reason}, nullptr,
       grpc_core::Thread::Options().set_tracked(false).set_joinable(false))
       .Start();
 }
@@ -74,16 +112,25 @@ bool ThreadPool::Queue::Step() {
   while (state_ == State::kRunning && callbacks_.empty()) {
     // If there are too many threads waiting, then quit this thread.
     // TODO(ctiller): wait some time in this case to be sure.
-    if (threads_waiting_ >= reserve_threads_) return false;
-    threads_waiting_++;
-    cv_.Wait(&mu_);
-    threads_waiting_--;
+    if (threads_waiting_ >= reserve_threads_) {
+      threads_waiting_++;
+      bool timeout = cv_.WaitWithTimeout(&mu_, absl::Seconds(30));
+      threads_waiting_--;
+      if (timeout && threads_waiting_ >= reserve_threads_) {
+        return false;
+      }
+    } else {
+      threads_waiting_++;
+      cv_.Wait(&mu_);
+      threads_waiting_--;
+    }
   }
   switch (state_) {
     case State::kRunning:
       break;
-    case State::kShutdown:
     case State::kForking:
+      return false;
+    case State::kShutdown:
       if (!callbacks_.empty()) break;
       return false;
   }
@@ -95,14 +142,13 @@ bool ThreadPool::Queue::Step() {
   return true;
 }
 
-ThreadPool::ThreadPool(int reserve_threads)
-    : reserve_threads_(reserve_threads) {
-  for (int i = 0; i < reserve_threads; i++) {
-    StartThread(state_, /*throttled=*/false);
+ThreadPool::ThreadPool() {
+  for (unsigned i = 0; i < reserve_threads_; i++) {
+    StartThread(state_, StartThreadReason::kInitialPool);
   }
 }
 
-ThreadPool::~ThreadPool() {
+void ThreadPool::Quiesce() {
   state_->queue.SetShutdown();
   // Wait until all threads are exited.
   // Note that if this is a threadpool thread then we won't exit this thread
@@ -110,17 +156,24 @@ ThreadPool::~ThreadPool() {
   // thread running instead of zero.
   state_->thread_count.BlockUntilThreadCount(g_threadpool_thread ? 1 : 0,
                                              "shutting down");
+  quiesced_.store(true, std::memory_order_relaxed);
+}
+
+ThreadPool::~ThreadPool() {
+  GPR_ASSERT(quiesced_.load(std::memory_order_relaxed));
 }
 
-void ThreadPool::Add(absl::AnyInvocable<void()> callback) {
+void ThreadPool::Run(absl::AnyInvocable<void()> callback) {
+  GPR_DEBUG_ASSERT(quiesced_.load(std::memory_order_relaxed) == false);
   if (state_->queue.Add(std::move(callback))) {
-    if (!state_->currently_starting_one_thread.exchange(
-            true, std::memory_order_relaxed)) {
-      StartThread(state_, /*throttled=*/true);
-    }
+    StartThread(state_, StartThreadReason::kNoWaitersWhenScheduling);
   }
 }
 
+void ThreadPool::Run(EventEngine::Closure* closure) {
+  Run([closure]() { closure->Run(); });
+}
+
 bool ThreadPool::Queue::Add(absl::AnyInvocable<void()> callback) {
   grpc_core::MutexLock lock(&mu_);
   // Add works to the callbacks list
@@ -129,13 +182,42 @@ bool ThreadPool::Queue::Add(absl::AnyInvocable<void()> callback) {
   switch (state_) {
     case State::kRunning:
     case State::kShutdown:
-      return threads_waiting_ == 0;
+      return callbacks_.size() > threads_waiting_;
     case State::kForking:
       return false;
   }
   GPR_UNREACHABLE_CODE(return false);
 }
 
+bool ThreadPool::Queue::IsBacklogged() {
+  grpc_core::MutexLock lock(&mu_);
+  switch (state_) {
+    case State::kRunning:
+    case State::kShutdown:
+      return callbacks_.size() > 1;
+    case State::kForking:
+      return false;
+  }
+  GPR_UNREACHABLE_CODE(return false);
+}
+
+void ThreadPool::Queue::SleepIfRunning() {
+  grpc_core::MutexLock lock(&mu_);
+  auto end = grpc_core::Duration::Seconds(1) + grpc_core::Timestamp::Now();
+  while (true) {
+    grpc_core::Timestamp now = grpc_core::Timestamp::Now();
+    if (now >= end) return;
+    switch (state_) {
+      case State::kRunning:
+      case State::kShutdown:
+        cv_.WaitWithTimeout(&mu_, absl::Milliseconds((end - now).millis()));
+        break;
+      case State::kForking:
+        return;
+    }
+  }
+}
+
 void ThreadPool::Queue::SetState(State state) {
   grpc_core::MutexLock lock(&mu_);
   if (state == State::kRunning) {
@@ -186,8 +268,8 @@ void ThreadPool::PostforkChild() { Postfork(); }
 
 void ThreadPool::Postfork() {
   state_->queue.Reset();
-  for (int i = 0; i < reserve_threads_; i++) {
-    StartThread(state_, /*throttled=*/false);
+  for (unsigned i = 0; i < reserve_threads_; i++) {
+    StartThread(state_, StartThreadReason::kInitialPool);
   }
 }
 

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

@@ -1,26 +1,28 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
 #define GRPC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <atomic>
 #include <memory>
 #include <queue>
@@ -28,19 +30,28 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/functional/any_invocable.h"
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/cpu.h>
+
+#include "src/core/lib/event_engine/executor/executor.h"
 #include "src/core/lib/event_engine/forkable.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-class ThreadPool final : public grpc_event_engine::experimental::Forkable {
+class ThreadPool final : public Forkable, public Executor {
  public:
-  explicit ThreadPool(int reserve_threads);
-  // Ensures the thread pool is empty before destroying it.
+  ThreadPool();
+  // Asserts Quiesce was called.
   ~ThreadPool() override;
 
-  void Add(absl::AnyInvocable<void()> callback);
+  void Quiesce();
+
+  // Run must not be called after Quiesce completes
+  void Run(absl::AnyInvocable<void()> callback) override;
+  void Run(EventEngine::Closure* closure) override;
 
   // Forkable
   // Ensures that the thread pool is empty before forking.
@@ -51,7 +62,8 @@ class ThreadPool final : public grpc_event_engine::experimental::Forkable {
  private:
   class Queue {
    public:
-    explicit Queue(int reserve_threads) : reserve_threads_(reserve_threads) {}
+    explicit Queue(unsigned reserve_threads)
+        : reserve_threads_(reserve_threads) {}
     bool Step();
     void SetShutdown() { SetState(State::kShutdown); }
     void SetForking() { SetState(State::kForking); }
@@ -59,6 +71,8 @@ class ThreadPool final : public grpc_event_engine::experimental::Forkable {
     // Return true if we should also spin up a new thread.
     bool Add(absl::AnyInvocable<void()> callback);
     void Reset() { SetState(State::kRunning); }
+    bool IsBacklogged();
+    void SleepIfRunning();
 
    private:
     enum class State { kRunning, kShutdown, kForking };
@@ -68,8 +82,8 @@ class ThreadPool final : public grpc_event_engine::experimental::Forkable {
     grpc_core::Mutex mu_;
     grpc_core::CondVar cv_;
     std::queue<absl::AnyInvocable<void()>> callbacks_ ABSL_GUARDED_BY(mu_);
-    int threads_waiting_ ABSL_GUARDED_BY(mu_) = 0;
-    const int reserve_threads_;
+    unsigned threads_waiting_ ABSL_GUARDED_BY(mu_) = 0;
+    const unsigned reserve_threads_;
     State state_ ABSL_GUARDED_BY(mu_) = State::kRunning;
   };
 
@@ -92,20 +106,29 @@ class ThreadPool final : public grpc_event_engine::experimental::Forkable {
     // After pool creation we use this to rate limit creation of threads to one
     // at a time.
     std::atomic<bool> currently_starting_one_thread{false};
+    std::atomic<uint64_t> last_started_thread{0};
   };
 
   using StatePtr = std::shared_ptr<State>;
 
+  enum class StartThreadReason {
+    kInitialPool,
+    kNoWaitersWhenScheduling,
+    kNoWaitersWhenFinishedStarting,
+  };
+
   static void ThreadFunc(StatePtr state);
   // Start a new thread; throttled indicates whether the State::starting_thread
   // variable is being used to throttle this threads creation against others or
   // not: at thread pool startup we start several threads concurrently, but
   // after that we only start one at a time.
-  static void StartThread(StatePtr state, bool throttled);
+  static void StartThread(StatePtr state, StartThreadReason reason);
   void Postfork();
 
-  const int reserve_threads_;
+  const unsigned reserve_threads_ =
+      grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 32u);
   const StatePtr state_ = std::make_shared<State>(reserve_threads_);
+  std::atomic<bool> quiesced_{false};
 };
 
 }  // namespace experimental

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

@@ -29,4 +29,4 @@ size_t Milliseconds(EventEngine::Duration d);
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H

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

@@ -26,6 +26,7 @@
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
+#include "src/core/lib/gprpp/crash.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -41,11 +42,11 @@ IOCP::IOCP(Executor* executor) noexcept
 // Shutdown must be called prior to deletion
 IOCP::~IOCP() {}
 
-WinSocket* IOCP::Watch(SOCKET socket) {
-  WinSocket* wrapped_socket = new WinSocket(socket, executor_);
-  HANDLE ret =
-      CreateIoCompletionPort(reinterpret_cast<HANDLE>(socket), iocp_handle_,
-                             reinterpret_cast<uintptr_t>(wrapped_socket), 0);
+std::unique_ptr<WinSocket> IOCP::Watch(SOCKET socket) {
+  auto wrapped_socket = std::make_unique<WinSocket>(socket, executor_);
+  HANDLE ret = CreateIoCompletionPort(
+      reinterpret_cast<HANDLE>(socket), iocp_handle_,
+      reinterpret_cast<uintptr_t>(wrapped_socket.get()), 0);
   if (!ret) {
     char* utf8_message = gpr_format_message(WSAGetLastError());
     gpr_log(GPR_ERROR, "Unable to add socket to iocp: %s", utf8_message);
@@ -94,8 +95,8 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
     if (completion_key == (ULONG_PTR)&kick_token_) {
       return Poller::WorkResult::kKicked;
     }
-    gpr_log(GPR_ERROR, "Unknown custom completion key: %p", completion_key);
-    abort();
+    grpc_core::Crash(
+        absl::StrFormat("Unknown custom completion key: %p", completion_key));
   }
   if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
     gpr_log(GPR_DEBUG, "IOCP::%p got event on OVERLAPPED::%p", this,
@@ -135,14 +136,14 @@ DWORD IOCP::GetDefaultSocketFlags() {
 
 DWORD IOCP::WSASocketFlagsInit() {
   DWORD wsa_socket_flags = WSA_FLAG_OVERLAPPED;
-  /* WSA_FLAG_NO_HANDLE_INHERIT may be not supported on the older Windows
-     versions, see
-     https://msdn.microsoft.com/en-us/library/windows/desktop/ms742212(v=vs.85).aspx
-     for details. */
+  // WSA_FLAG_NO_HANDLE_INHERIT may be not supported on the older Windows
+  // versions, see
+  // https://msdn.microsoft.com/en-us/library/windows/desktop/ms742212(v=vs.85).aspx
+  // for details.
   SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
                           wsa_socket_flags | WSA_FLAG_NO_HANDLE_INHERIT);
   if (sock != INVALID_SOCKET) {
-    /* Windows 7, Windows 2008 R2 with SP1 or later */
+    // Windows 7, Windows 2008 R2 with SP1 or later
     wsa_socket_flags |= WSA_FLAG_NO_HANDLE_INHERIT;
     closesocket(sock);
   }

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

@@ -46,7 +46,7 @@ class IOCP final : public Poller {
                   absl::FunctionRef<void()> schedule_poll_again) override;
   void Kick() override;
 
-  WinSocket* Watch(SOCKET socket);
+  std::unique_ptr<WinSocket> Watch(SOCKET socket);
   // Return the set of default flags
   static DWORD GetDefaultSocketFlags();
 

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

@@ -24,8 +24,8 @@
 #include "src/core/lib/iomgr/error.h"
 
 #if defined(__MSYS__) && defined(GPR_ARCH_64)
-/* Nasty workaround for nasty bug when using the 64 bits msys compiler
-   in conjunction with Microsoft Windows headers. */
+// Nasty workaround for nasty bug when using the 64 bits msys compiler
+// in conjunction with Microsoft Windows headers.
 #define GRPC_FIONBIO _IOW('f', 126, uint32_t)
 #else
 #define GRPC_FIONBIO FIONBIO
@@ -151,7 +151,7 @@ grpc_error_handle grpc_tcp_set_non_block(SOCKET sock) {
   status = WSAIoctl(sock, GRPC_FIONBIO, &param, sizeof(param), NULL, 0, &ret,
                     NULL, NULL);
   return status == 0
-             ? GRPC_ERROR_NONE
+             ? absl::OkStatus()
              : GRPC_WSA_ERROR(WSAGetLastError(), "WSAIoctl(GRPC_FIONBIO)");
 }
 
@@ -161,7 +161,7 @@ static grpc_error_handle set_dualstack(SOCKET sock) {
   status = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&param,
                       sizeof(param));
   return status == 0
-             ? GRPC_ERROR_NONE
+             ? absl::OkStatus()
              : GRPC_WSA_ERROR(WSAGetLastError(), "setsockopt(IPV6_V6ONLY)");
 }
 
@@ -173,7 +173,7 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
   if (status == SOCKET_ERROR) {
     status = WSAGetLastError();
   }
-  return status == 0 ? GRPC_ERROR_NONE
+  return status == 0 ? absl::OkStatus()
                      : GRPC_WSA_ERROR(status, "setsockopt(TCP_NODELAY)");
 }
 
@@ -182,12 +182,12 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
 absl::Status PrepareSocket(SOCKET sock) {
   absl::Status err;
   err = grpc_tcp_set_non_block(sock);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   err = enable_socket_low_latency(sock);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   err = set_dualstack(sock);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
-  return GRPC_ERROR_NONE;
+  if (!err.ok()) return err;
+  return absl::OkStatus();
 }
 
 }  // namespace experimental

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

@@ -26,13 +26,13 @@
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
 
-#include "src/core/lib/event_engine/executor/threaded_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/trace.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/windows_engine.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 
@@ -45,7 +45,7 @@ namespace experimental {
 
 struct WindowsEventEngine::Closure final : public EventEngine::Closure {
   absl::AnyInvocable<void()> cb;
-  posix_engine::Timer timer;
+  Timer timer;
   WindowsEventEngine* engine;
   EventEngine::TaskHandle handle;
 
@@ -61,23 +61,30 @@ struct WindowsEventEngine::Closure final : public EventEngine::Closure {
   }
 };
 
-WindowsEventEngine::WindowsEventEngine() : iocp_(&executor_) {
+WindowsEventEngine::WindowsEventEngine()
+    : executor_(std::make_shared<ThreadPool>()),
+      iocp_(executor_.get()),
+      timer_manager_(executor_) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
   GPR_ASSERT(status == 0);
 }
 
 WindowsEventEngine::~WindowsEventEngine() {
-  grpc_core::MutexLock lock(&mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-    for (auto handle : known_handles_) {
-      gpr_log(GPR_ERROR,
-              "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s", this,
-              HandleToString(handle).c_str());
+  {
+    grpc_core::MutexLock lock(&mu_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      for (auto handle : known_handles_) {
+        gpr_log(GPR_ERROR,
+                "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s",
+                this, HandleToString(handle).c_str());
+      }
     }
+    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    GPR_ASSERT(WSACleanup() == 0);
+    timer_manager_.Shutdown();
   }
-  GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
-  GPR_ASSERT(WSACleanup() == 0);
+  executor_->Quiesce();
 }
 
 bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
@@ -101,11 +108,11 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfter(
 }
 
 void WindowsEventEngine::Run(absl::AnyInvocable<void()> closure) {
-  executor_.Run(std::move(closure));
+  executor_->Run(std::move(closure));
 }
 
 void WindowsEventEngine::Run(EventEngine::Closure* closure) {
-  executor_.Run(closure);
+  executor_->Run(closure);
 }
 
 EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
@@ -127,22 +134,20 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
 
 std::unique_ptr<EventEngine::DNSResolver> WindowsEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-bool WindowsEventEngine::IsWorkerThread() {
-  GPR_ASSERT(false && "unimplemented");
-}
+bool WindowsEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
 
 bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     OnConnectCallback on_connect, const ResolvedAddress& addr,
     const EndpointConfig& args, MemoryAllocator memory_allocator,
     Duration deadline) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
@@ -151,9 +156,10 @@ WindowsEventEngine::CreateListener(
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const EndpointConfig& config,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
+
 #endif  // GPR_WINDOWS