grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -0,0 +1,68 @@
+// 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) 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 (absl::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

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

@@ -0,0 +1,120 @@
+// 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_WINDOWS_ENGINE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#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/windows/iocp.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class WindowsEventEngine : public EventEngine {
+ public:
+  class WindowsEndpoint : public EventEngine::Endpoint {
+   public:
+    ~WindowsEndpoint() override;
+    void Read(absl::AnyInvocable<void(absl::Status)> on_read,
+              SliceBuffer* buffer, const ReadArgs* args) override;
+    void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+               SliceBuffer* data, const WriteArgs* args) override;
+    const ResolvedAddress& GetPeerAddress() const override;
+    const ResolvedAddress& GetLocalAddress() const override;
+  };
+  class WindowsListener : public EventEngine::Listener {
+   public:
+    ~WindowsListener() override;
+    absl::StatusOr<int> Bind(const ResolvedAddress& addr) override;
+    absl::Status Start() override;
+  };
+  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;
+  };
+
+  WindowsEventEngine();
+  ~WindowsEventEngine() override;
+
+  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;
+  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:
+  struct Closure;
+  EventEngine::TaskHandle RunAfterInternal(Duration when,
+                                           absl::AnyInvocable<void()> cb);
+  grpc_core::Mutex mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
+  std::atomic<intptr_t> aba_token_{0};
+
+  posix_engine::TimerManager timer_manager_;
+  ThreadedExecutor executor_{2};
+  IOCP iocp_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H

data/src/core/lib/gpr/time.cc

@@ -77,16 +77,18 @@ static gpr_timespec to_seconds_from_sub_second_time(int64_t time_in_units,
   } else if (time_in_units == INT64_MIN) {
     out = gpr_inf_past(type);
   } else {
-    if (time_in_units >= 0) {
-      out.tv_sec = time_in_units / units_per_sec;
-    } else {
-      out.tv_sec = (-((units_per_sec - 1) - (time_in_units + units_per_sec)) /
-                    units_per_sec) -
-                   1;
-    }
+    GPR_DEBUG_ASSERT(GPR_NS_PER_SEC % units_per_sec == 0);
+
+    out.tv_sec = time_in_units / units_per_sec;
     out.tv_nsec =
-        static_cast<int32_t>((time_in_units - out.tv_sec * units_per_sec) *
-                             GPR_NS_PER_SEC / units_per_sec);
+        static_cast<int32_t>((time_in_units - (out.tv_sec * units_per_sec)) *
+                             (GPR_NS_PER_SEC / units_per_sec));
+    /// `out.tv_nsec` should always be positive.
+    if (out.tv_nsec < 0) {
+      out.tv_nsec += GPR_NS_PER_SEC;
+      out.tv_sec--;
+    }
+
     out.clock_type = type;
   }
   return out;