grpc 1.48.0 → 1.50.0

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

@@ -0,0 +1,155 @@
+// Copyright 2022 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>
+
+#ifdef GPR_WINDOWS
+
+#include <chrono>
+
+#include "absl/strings/str_format.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log_windows.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"
+#include "src/core/lib/event_engine/windows/win_socket.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+IOCP::IOCP(Executor* executor) noexcept
+    : executor_(executor),
+      iocp_handle_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL,
+                                          (ULONG_PTR)NULL, 0)) {
+  GPR_ASSERT(iocp_handle_);
+  WSASocketFlagsInit();
+}
+
+// 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);
+  if (!ret) {
+    char* utf8_message = gpr_format_message(WSAGetLastError());
+    gpr_log(GPR_ERROR, "Unable to add socket to iocp: %s", utf8_message);
+    gpr_free(utf8_message);
+    __debugbreak();
+    abort();
+  }
+  GPR_ASSERT(ret == iocp_handle_);
+  return wrapped_socket;
+}
+
+void IOCP::Shutdown() {
+  while (outstanding_kicks_.load() > 0) {
+    Work(std::chrono::hours(42), []() {});
+  }
+  GPR_ASSERT(CloseHandle(iocp_handle_));
+}
+
+Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
+                              absl::FunctionRef<void()> schedule_poll_again) {
+  static const absl::Status kDeadlineExceeded = absl::DeadlineExceededError(
+      absl::StrFormat("IOCP::%p: Received no completions", this));
+  static const absl::Status kKicked =
+      absl::AbortedError(absl::StrFormat("IOCP::%p: Awoken from a kick", this));
+  DWORD bytes = 0;
+  ULONG_PTR completion_key;
+  LPOVERLAPPED overlapped;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+    gpr_log(GPR_DEBUG, "IOCP::%p doing work", this);
+  }
+  BOOL success = GetQueuedCompletionStatus(
+      iocp_handle_, &bytes, &completion_key, &overlapped,
+      static_cast<DWORD>(Milliseconds(timeout)));
+  if (success == 0 && overlapped == NULL) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      gpr_log(GPR_DEBUG, "IOCP::%p deadline exceeded", this);
+    }
+    return Poller::WorkResult::kDeadlineExceeded;
+  }
+  GPR_ASSERT(completion_key && overlapped);
+  if (overlapped == &kick_overlap_) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      gpr_log(GPR_DEBUG, "IOCP::%p kicked", this);
+    }
+    outstanding_kicks_.fetch_sub(1);
+    if (completion_key == (ULONG_PTR)&kick_token_) {
+      return Poller::WorkResult::kKicked;
+    }
+    gpr_log(GPR_ERROR, "Unknown custom completion key: %p", completion_key);
+    abort();
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+    gpr_log(GPR_DEBUG, "IOCP::%p got event on OVERLAPPED::%p", this,
+            overlapped);
+  }
+  WinSocket* socket = reinterpret_cast<WinSocket*>(completion_key);
+  // TODO(hork): move the following logic into the WinSocket impl.
+  WinSocket::OpState* info = socket->GetOpInfoForOverlapped(overlapped);
+  GPR_ASSERT(info != nullptr);
+  if (socket->IsShutdown()) {
+    info->SetError(WSAESHUTDOWN);
+  } else {
+    info->GetOverlappedResult();
+  }
+  if (info->closure() != nullptr) {
+    schedule_poll_again();
+    executor_->Run(info->closure());
+    return Poller::WorkResult::kOk;
+  }
+  // No callback registered. Set ready and return an empty set
+  info->SetReady();
+  schedule_poll_again();
+  return Poller::WorkResult::kOk;
+}
+
+void IOCP::Kick() {
+  outstanding_kicks_.fetch_add(1);
+  GPR_ASSERT(PostQueuedCompletionStatus(
+      iocp_handle_, 0, reinterpret_cast<ULONG_PTR>(&kick_token_),
+      &kick_overlap_));
+}
+
+DWORD IOCP::GetDefaultSocketFlags() {
+  static DWORD wsa_socket_flags = WSASocketFlagsInit();
+  return wsa_socket_flags;
+}
+
+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. */
+  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 */
+    wsa_socket_flags |= WSA_FLAG_NO_HANDLE_INHERIT;
+    closesocket(sock);
+  }
+  return wsa_socket_flags;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_WINDOWS

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

@@ -0,0 +1,69 @@
+// Copyright 2022 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_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include "absl/status/status.h"
+
+#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/windows/win_socket.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class IOCP final : public Poller {
+ public:
+  explicit IOCP(Executor* executor) noexcept;
+  ~IOCP();
+  // Not copyable
+  IOCP(const IOCP&) = delete;
+  IOCP& operator=(const IOCP&) = delete;
+  // Not moveable
+  IOCP(IOCP&& other) = delete;
+  IOCP& operator=(IOCP&& other) = delete;
+
+  // interface methods
+  void Shutdown();
+  WorkResult Work(EventEngine::Duration timeout,
+                  absl::FunctionRef<void()> schedule_poll_again) override;
+  void Kick() override;
+
+  WinSocket* Watch(SOCKET socket);
+  // Return the set of default flags
+  static DWORD GetDefaultSocketFlags();
+
+ private:
+  // Initialize default flags via checking platform support
+  static DWORD WSASocketFlagsInit();
+
+  Executor* executor_;
+  HANDLE iocp_handle_;
+  OVERLAPPED kick_overlap_;
+  ULONG kick_token_;
+  std::atomic<int> outstanding_kicks_{0};
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H

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

@@ -0,0 +1,196 @@
+// Copyright 2022 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>
+
+#ifdef GPR_WINDOWS
+#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/trace.h"
+#include "src/core/lib/event_engine/windows/win_socket.h"
+#include "src/core/lib/gprpp/sync.h"
+#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. */
+#define GRPC_FIONBIO _IOW('f', 126, uint32_t)
+#else
+#define GRPC_FIONBIO FIONBIO
+#endif
+
+namespace grpc_event_engine {
+namespace experimental {
+
+WinSocket::WinSocket(SOCKET socket, Executor* executor) noexcept
+    : socket_(socket),
+      executor_(executor),
+      read_info_(OpState(this)),
+      write_info_(OpState(this)) {}
+
+WinSocket::~WinSocket() { GPR_ASSERT(is_shutdown_.load()); }
+
+SOCKET WinSocket::socket() { return socket_; }
+
+void WinSocket::MaybeShutdown(absl::Status why) {
+  // if already shutdown, return early. Otherwise, set the shutdown flag.
+  if (is_shutdown_.exchange(true)) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      gpr_log(GPR_DEBUG, "WinSocket::%p already shutting down", this);
+    }
+    return;
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+    gpr_log(GPR_DEBUG, "WinSocket::%p shutting down now. Reason: %s", this,
+            why.ToString().c_str());
+  }
+  // Grab the function pointer for DisconnectEx for that specific socket.
+  // It may change depending on the interface.
+  GUID guid = WSAID_DISCONNECTEX;
+  LPFN_DISCONNECTEX DisconnectEx;
+  DWORD ioctl_num_bytes;
+  int status = WSAIoctl(socket_, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid,
+                        sizeof(guid), &DisconnectEx, sizeof(DisconnectEx),
+                        &ioctl_num_bytes, NULL, NULL);
+
+  if (status == 0) {
+    DisconnectEx(socket_, NULL, 0, 0);
+  } else {
+    char* utf8_message = gpr_format_message(WSAGetLastError());
+    gpr_log(GPR_INFO, "Unable to retrieve DisconnectEx pointer : %s",
+            utf8_message);
+    gpr_free(utf8_message);
+  }
+  closesocket(socket_);
+}
+
+void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
+  if (IsShutdown()) {
+    info.SetError(WSAESHUTDOWN);
+    executor_->Run(closure);
+    return;
+  };
+  if (std::exchange(info.has_pending_iocp_, false)) {
+    executor_->Run(closure);
+  } else {
+    info.closure_ = closure;
+  }
+}
+
+void WinSocket::NotifyOnRead(EventEngine::Closure* on_read) {
+  NotifyOnReady(read_info_, on_read);
+}
+
+void WinSocket::NotifyOnWrite(EventEngine::Closure* on_write) {
+  NotifyOnReady(write_info_, on_write);
+}
+
+WinSocket::OpState::OpState(WinSocket* win_socket) noexcept
+    : win_socket_(win_socket), closure_(nullptr) {}
+
+void WinSocket::OpState::SetReady() {
+  GPR_ASSERT(!has_pending_iocp_);
+  if (closure_) {
+    win_socket_->executor_->Run(closure_);
+  } else {
+    has_pending_iocp_ = true;
+  }
+}
+
+void WinSocket::OpState::SetError(int wsa_error) {
+  bytes_transferred_ = 0;
+  wsa_error_ = wsa_error;
+}
+
+void WinSocket::OpState::GetOverlappedResult() {
+  DWORD flags = 0;
+  DWORD bytes;
+  BOOL success = WSAGetOverlappedResult(win_socket_->socket(), &overlapped_,
+                                        &bytes, FALSE, &flags);
+  bytes_transferred_ = bytes;
+  wsa_error_ = success ? 0 : WSAGetLastError();
+}
+
+void WinSocket::SetReadable() { read_info_.SetReady(); }
+
+void WinSocket::SetWritable() { write_info_.SetReady(); }
+
+bool WinSocket::IsShutdown() { return is_shutdown_.load(); }
+
+WinSocket::OpState* WinSocket::GetOpInfoForOverlapped(OVERLAPPED* overlapped) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+    gpr_log(GPR_DEBUG,
+            "WinSocket::%p looking for matching OVERLAPPED::%p. "
+            "read(%p) write(%p)",
+            this, overlapped, &read_info_.overlapped_,
+            &write_info_.overlapped_);
+  }
+  if (overlapped == &read_info_.overlapped_) return &read_info_;
+  if (overlapped == &write_info_.overlapped_) return &write_info_;
+  return nullptr;
+}
+
+namespace {
+
+grpc_error_handle grpc_tcp_set_non_block(SOCKET sock) {
+  int status;
+  uint32_t param = 1;
+  DWORD ret;
+  status = WSAIoctl(sock, GRPC_FIONBIO, &param, sizeof(param), NULL, 0, &ret,
+                    NULL, NULL);
+  return status == 0
+             ? GRPC_ERROR_NONE
+             : GRPC_WSA_ERROR(WSAGetLastError(), "WSAIoctl(GRPC_FIONBIO)");
+}
+
+static grpc_error_handle set_dualstack(SOCKET sock) {
+  int status;
+  DWORD param = 0;
+  status = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&param,
+                      sizeof(param));
+  return status == 0
+             ? GRPC_ERROR_NONE
+             : GRPC_WSA_ERROR(WSAGetLastError(), "setsockopt(IPV6_V6ONLY)");
+}
+
+static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
+  int status;
+  BOOL param = TRUE;
+  status = ::setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
+                        reinterpret_cast<char*>(&param), sizeof(param));
+  if (status == SOCKET_ERROR) {
+    status = WSAGetLastError();
+  }
+  return status == 0 ? GRPC_ERROR_NONE
+                     : GRPC_WSA_ERROR(status, "setsockopt(TCP_NODELAY)");
+}
+
+}  // namespace
+
+absl::Status PrepareSocket(SOCKET sock) {
+  absl::Status err;
+  err = grpc_tcp_set_non_block(sock);
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  err = enable_socket_low_latency(sock);
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  err = set_dualstack(sock);
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  return GRPC_ERROR_NONE;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_WINDOWS

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

@@ -0,0 +1,120 @@
+// Copyright 2022 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_WINDOWS_WIN_SOCKET_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WIN_SOCKET_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/executor/executor.h"
+#include "src/core/lib/event_engine/socket_notifier.h"
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class WinSocket final : public SocketNotifier {
+ public:
+  // State related to a Read or Write socket operation
+  class OpState {
+   public:
+    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
+    // be set.
+    void SetReady();
+    // Set error results for a completed op
+    void SetError(int wsa_error);
+    // Retrieve results of overlapped operation (via Winsock API)
+    void GetOverlappedResult();
+    // OVERLAPPED, needed for Winsock API calls
+    LPOVERLAPPED overlapped() { return &overlapped_; }
+    // Data from the previous operation, set via GetOverlappedResult
+    DWORD bytes_transferred() const { return bytes_transferred_; }
+    // Previous error if set.
+    int wsa_error() const { return wsa_error_; }
+    EventEngine::Closure* closure() { return closure_; }
+
+   private:
+    friend class WinSocket;
+
+    OVERLAPPED overlapped_;
+    WinSocket* win_socket_ = nullptr;
+    EventEngine::Closure* closure_ = nullptr;
+    bool has_pending_iocp_ = false;
+    DWORD bytes_transferred_;
+    int wsa_error_;
+  };
+
+  WinSocket(SOCKET socket, Executor* executor) noexcept;
+  ~WinSocket();
+  // Calling NotifyOnRead means either of two things:
+  //  - The IOCP already completed in the background, and we need to call
+  //    the callback now.
+  //  - The IOCP hasn't completed yet, and we're queuing it for later.
+  void NotifyOnRead(EventEngine::Closure* on_read) override;
+  void NotifyOnWrite(EventEngine::Closure* on_write) override;
+  void SetReadable() override;
+  void SetWritable() override;
+  // Schedule a shutdown of the socket operations. Will call the pending
+  // operations to abort them. We need to do that this way because of the
+  // various callsites of that function, which happens to be in various
+  // mutex hold states, and that'd be unsafe to call them directly.
+  void MaybeShutdown(absl::Status why) override;
+  bool IsShutdown() override;
+
+  // Return the appropriate OpState for a given OVERLAPPED
+  // Returns nullptr if the overlapped does not match either read or write ops.
+  OpState* GetOpInfoForOverlapped(OVERLAPPED* overlapped);
+  // Getters for the operation state data.
+  OpState* read_info() { return &read_info_; }
+  OpState* write_info() { return &write_info_; }
+  // Accessor method for underlying socket
+  SOCKET socket();
+
+ private:
+  void NotifyOnReady(OpState& info, EventEngine::Closure* closure);
+
+  SOCKET socket_;
+  std::atomic<bool> is_shutdown_{false};
+  Executor* executor_;
+  // 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
+  // GetOverlappedResult has returned, to ensure there are no two threads
+  // reading and writing the same values concurrently.
+  //
+  // Callers must also ensure that at most one read and write operation are
+  // occurring at a time. Attempting to do multiple concurrent reads/writes will
+  // have undefined behavior.
+  OpState read_info_;
+  OpState write_info_;
+};
+
+// Attempt to configure default socket settings
+absl::Status PrepareSocket(SOCKET sock);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WIN_SOCKET_H

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

@@ -0,0 +1,159 @@
+// Copyright 2022 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.
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <memory>
+
+#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>
+#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/sync.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// TODO(hork): The iomgr timer and execution engine can be reused. It should
+// be separated out from the posix_engine and instantiated as components. It is
+// effectively copied below.
+
+struct WindowsEventEngine::Closure final : public EventEngine::Closure {
+  absl::AnyInvocable<void()> cb;
+  posix_engine::Timer timer;
+  WindowsEventEngine* engine;
+  EventEngine::TaskHandle handle;
+
+  void Run() override {
+    GRPC_EVENT_ENGINE_TRACE("WindowsEventEngine:%p executing callback:%s",
+                            engine, HandleToString(handle).c_str());
+    {
+      grpc_core::MutexLock lock(&engine->mu_);
+      engine->known_handles_.erase(handle);
+    }
+    cb();
+    delete this;
+  }
+};
+
+WindowsEventEngine::WindowsEventEngine() : iocp_(&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());
+    }
+  }
+  GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+  GPR_ASSERT(WSACleanup() == 0);
+}
+
+bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
+  grpc_core::MutexLock lock(&mu_);
+  if (!known_handles_.contains(handle)) return false;
+  auto* cd = reinterpret_cast<Closure*>(handle.keys[0]);
+  bool r = timer_manager_.TimerCancel(&cd->timer);
+  known_handles_.erase(handle);
+  if (r) delete cd;
+  return r;
+}
+
+EventEngine::TaskHandle WindowsEventEngine::RunAfter(
+    Duration when, absl::AnyInvocable<void()> closure) {
+  return RunAfterInternal(when, std::move(closure));
+}
+
+EventEngine::TaskHandle WindowsEventEngine::RunAfter(
+    Duration when, EventEngine::Closure* closure) {
+  return RunAfterInternal(when, [closure]() { closure->Run(); });
+}
+
+void WindowsEventEngine::Run(absl::AnyInvocable<void()> closure) {
+  executor_.Run(std::move(closure));
+}
+
+void WindowsEventEngine::Run(EventEngine::Closure* closure) {
+  executor_.Run(closure);
+}
+
+EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
+    Duration when, absl::AnyInvocable<void()> cb) {
+  auto when_ts = ToTimestamp(timer_manager_.Now(), when);
+  auto* cd = new Closure;
+  cd->cb = std::move(cb);
+  cd->engine = this;
+  EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
+                                 aba_token_.fetch_add(1)};
+  grpc_core::MutexLock lock(&mu_);
+  known_handles_.insert(handle);
+  cd->handle = handle;
+  GRPC_EVENT_ENGINE_TRACE("WindowsEventEngine:%p scheduling callback:%s", this,
+                          HandleToString(handle).c_str());
+  timer_manager_.TimerInit(&cd->timer, when_ts, cd);
+  return handle;
+}
+
+std::unique_ptr<EventEngine::DNSResolver> WindowsEventEngine::GetDNSResolver(
+    EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+bool WindowsEventEngine::IsWorkerThread() {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+EventEngine::ConnectionHandle WindowsEventEngine::Connect(
+    OnConnectCallback on_connect, const ResolvedAddress& addr,
+    const EndpointConfig& args, MemoryAllocator memory_allocator,
+    Duration deadline) {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+WindowsEventEngine::CreateListener(
+    Listener::AcceptCallback on_accept,
+    absl::AnyInvocable<void(absl::Status)> on_shutdown,
+    const EndpointConfig& config,
+    std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+#endif  // GPR_WINDOWS