grpc 1.71.0 → 1.72.0

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

@@ -395,10 +395,17 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
     // reduce the check rate if the pool is idle.
     if (pool_->IsShutdown()) {
       if (pool_->IsQuiesced()) break;
-    } else {
-      lifeguard_should_shut_down_->WaitForNotificationWithTimeout(
-          absl::Milliseconds(backoff_.NextAttemptDelay().millis()));
+      if (MaybeStartNewThread()) {
+        // A new thread needed to be spawned to handle the workload.
+        // Wait just a small while before checking again to prevent a busy loop.
+        backoff_.Reset();
+      }
+      // Sleep for a bit.
+      pool_->work_signal()->WaitWithTimeout(backoff_.NextAttemptDelay());
+      continue;
     }
+    lifeguard_should_shut_down_->WaitForNotificationWithTimeout(
+        absl::Milliseconds(backoff_.NextAttemptDelay().millis()));
     MaybeStartNewThread();
   }
   lifeguard_running_.store(false, std::memory_order_relaxed);
@@ -422,11 +429,11 @@ WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::~Lifeguard() {
   lifeguard_is_shut_down_ = std::make_unique<grpc_core::Notification>();
 }
 
-void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
+bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
     MaybeStartNewThread() {
   // No new threads are started when forking.
   // No new work is done when forking needs to begin.
-  if (pool_->forking_.load()) return;
+  if (pool_->forking_.load()) return false;
   const auto living_thread_count = pool_->living_thread_count()->count();
   // Wake an idle worker thread if there's global work to be had.
   if (pool_->busy_thread_count()->count() < living_thread_count) {
@@ -435,7 +442,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
       backoff_.Reset();
     }
     // Idle threads will eventually wake up for an attempt at work stealing.
-    return;
+    return false;
   }
   // No new threads if in the throttled state.
   // However, all workers are busy, so the Lifeguard should be more
@@ -445,7 +452,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
               pool_->last_started_thread_) <
       kTimeBetweenThrottledThreadStarts) {
     backoff_.Reset();
-    return;
+    return false;
   }
   // All workers are busy and the pool is not throttled. Start a new thread.
   // TODO(hork): new threads may spawn when there is no work in the global
@@ -457,6 +464,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
   pool_->StartThread();
   // Tell the lifeguard to monitor the pool more closely.
   backoff_.Reset();
+  return true;
 }
 
 // -------- WorkStealingThreadPool::ThreadState --------

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

@@ -158,7 +158,8 @@ class WorkStealingThreadPool final : public ThreadPool {
       // The main body of the lifeguard thread.
       void LifeguardMain();
       // Starts a new thread if the pool is backlogged
-      void MaybeStartNewThread();
+      // Return true if a new thread was started.
+      bool MaybeStartNewThread();
 
       WorkStealingThreadPoolImpl* pool_;
       grpc_core::BackOff backoff_;

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

@@ -233,6 +233,17 @@ absl::Status PrepareSocket(SOCKET sock) {
   return absl::OkStatus();
 }
 
+absl::StatusOr<EventEngine::ResolvedAddress> SocketToAddress(SOCKET socket) {
+  char addr[EventEngine::ResolvedAddress::MAX_SIZE_BYTES];
+  int addr_len = sizeof(addr);
+  if (getsockname(socket, reinterpret_cast<sockaddr*>(addr), &addr_len) < 0) {
+    return GRPC_WSA_ERROR(WSAGetLastError(),
+                          "Failed to get local socket name using getsockname");
+  }
+  return EventEngine::ResolvedAddress(reinterpret_cast<sockaddr*>(addr),
+                                      addr_len);
+}
+
 }  // namespace grpc_event_engine::experimental
 
 #endif  // GPR_WINDOWS

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

@@ -133,6 +133,9 @@ absl::Status PrepareSocket(SOCKET sock);
 // Set non block option for socket.
 absl::Status SetSocketNonBlock(SOCKET sock);
 
+// Get the local address of a socket.
+absl::StatusOr<EventEngine::ResolvedAddress> SocketToAddress(SOCKET sock);
+
 }  // namespace grpc_event_engine::experimental
 
 #endif

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

@@ -26,6 +26,7 @@
 #include "absl/strings/str_format.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/windows/win_socket.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/util/debug_location.h"
@@ -57,16 +58,10 @@ WindowsEndpoint::WindowsEndpoint(
       allocator_(std::move(allocator)),
       io_state_(std::make_shared<AsyncIOState>(
           this, std::move(socket), std::move(engine), thread_pool)) {
-  char addr[EventEngine::ResolvedAddress::MAX_SIZE_BYTES];
-  int addr_len = sizeof(addr);
-  if (getsockname(io_state_->socket->raw_socket(),
-                  reinterpret_cast<sockaddr*>(addr), &addr_len) < 0) {
-    grpc_core::Crash(absl::StrFormat(
-        "Unrecoverable error: Failed to get local socket name. %s",
-        GRPC_WSA_ERROR(WSAGetLastError(), "getsockname").ToString().c_str()));
-  }
-  local_address_ =
-      EventEngine::ResolvedAddress(reinterpret_cast<sockaddr*>(addr), addr_len);
+  auto local_address = SocketToAddress(io_state_->socket->raw_socket());
+  CHECK(local_address.ok())
+      << "Failed to get local socket address: " << local_address.status();
+  local_address_ = std::move(*local_address);
   local_address_string_ = *ResolvedAddressToURI(local_address_);
   peer_address_string_ = *ResolvedAddressToURI(peer_address_);
 }

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

@@ -43,6 +43,7 @@
 #include "src/core/lib/event_engine/windows/windows_engine.h"
 #include "src/core/lib/event_engine/windows/windows_listener.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/dump_args.h"
@@ -258,6 +259,47 @@ bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
   return r;
 }
 
+std::unique_ptr<EventEngine::Endpoint>
+WindowsEventEngine::CreateEndpointFromWinSocket(SOCKET socket,
+                                                const EndpointConfig& config) {
+  // Get address from socket.
+  auto local_address = SocketToAddress(socket);
+  if (!local_address.ok()) {
+    LOG(ERROR) << "WindowsEventEngine::" << this
+               << ": Error getting local socket address: "
+               << local_address.status();
+    return nullptr;
+  }
+  // Create winsocket and ensure IOCP is polling it.
+  auto winsocket = iocp_.Watch(socket);
+  if (winsocket == nullptr) {
+    LOG(ERROR) << "WindowsEventEngine::" << this
+               << ": Error registering socket with IOCP engine.";
+    return nullptr;
+  }
+  // Get the config's memory allocator factory if present, or fall back to the
+  // resource quota.
+  MemoryAllocator allocator;
+  auto local_address_string = *ResolvedAddressToURI(*local_address);
+  auto* allocator_factory =
+      config.GetVoidPointer(GRPC_ARG_EVENT_ENGINE_USE_MEMORY_ALLOCATOR_FACTORY);
+  if (allocator_factory != nullptr) {
+    allocator = static_cast<MemoryAllocatorFactory*>(allocator_factory)
+                    ->CreateMemoryAllocator(local_address_string);
+  } else {
+    auto* rqv = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
+    CHECK_NE(rqv, nullptr) << "WindowsEventEngine::" << this
+                           << ": config does not contain a resource quota. "
+                              "This should not happen.";
+    allocator = static_cast<grpc_core::ResourceQuota*>(rqv)
+                    ->memory_quota()
+                    ->CreateMemoryAllocator(local_address_string);
+  }
+  return std::make_unique<WindowsEndpoint>(
+      std::move(*local_address), std::move(winsocket), std::move(allocator),
+      config, thread_pool_.get(), shared_from_this());
+}
+
 EventEngine::TaskHandle WindowsEventEngine::RunAfter(
     Duration when, absl::AnyInvocable<void()> closure) {
   return RunAfterInternal(when, std::move(closure));

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

@@ -31,8 +31,10 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "src/core/lib/event_engine/ares_resolver.h"
+#include "src/core/lib/event_engine/extensions/supports_win_sockets.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/query_extensions.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
@@ -42,8 +44,9 @@
 
 namespace grpc_event_engine::experimental {
 
-class WindowsEventEngine : public EventEngine,
-                           public grpc_core::KeepsGrpcInitialized {
+class WindowsEventEngine
+    : public grpc_core::KeepsGrpcInitialized,
+      public ExtendedType<EventEngine, EventEngineWindowsSocketSupport> {
  public:
   class WindowsDNSResolver : public EventEngine::DNSResolver {
    public:
@@ -93,6 +96,9 @@ class WindowsEventEngine : public EventEngine,
                       absl::AnyInvocable<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
 
+  std::unique_ptr<EventEngine::Endpoint> CreateEndpointFromWinSocket(
+      SOCKET socket, const EndpointConfig& config) override;
+
   // Retrieve the base ThreadPool.
   // This is public because most classes that know the concrete
   // WindowsEventEngine type are effectively friends.

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

@@ -19,6 +19,7 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
+#include "src/core/lib/event_engine/extensions/iomgr_compatible.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
@@ -257,10 +258,8 @@ WindowsEventEngineListener::SinglePortSocketListener::PrepareListenerSocket(
     SOCKET sock, const EventEngine::ResolvedAddress& addr) {
   auto fail = [&](absl::Status error) -> absl::Status {
     CHECK(!error.ok());
-    error = grpc_error_set_int(
-        GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket", &error,
-                                      1),
-        grpc_core::StatusIntProperty::kFd, static_cast<intptr_t>(sock));
+    error = GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket",
+                                          &error, 1);
     if (sock != INVALID_SOCKET) closesocket(sock);
     return error;
   };
@@ -308,7 +307,7 @@ WindowsEventEngineListener::WindowsEventEngineListener(
 
 WindowsEventEngineListener::~WindowsEventEngineListener() {
   GRPC_TRACE_LOG(event_engine, INFO) << "~WindowsEventEngineListener::" << this;
-  ShutdownListeners();
+  Shutdown();
   on_shutdown_(absl::OkStatus());
 }
 
@@ -368,7 +367,7 @@ absl::Status WindowsEventEngineListener::Start() {
   return absl::OkStatus();
 }
 
-void WindowsEventEngineListener::ShutdownListeners() {
+void WindowsEventEngineListener::Shutdown() {
   grpc_core::MutexLock lock(&port_listeners_mu_);
   if (std::exchange(listeners_shutdown_, true)) return;
   // Shut down each port listener before destroying this EventEngine::Listener

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

@@ -26,6 +26,8 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/statusor.h"
 #include "src/core/lib/event_engine/common_closures.h"
+#include "src/core/lib/event_engine/extensions/iomgr_compatible.h"
+#include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/iomgr/port.h"
@@ -40,7 +42,10 @@
 
 namespace grpc_event_engine::experimental {
 
-class WindowsEventEngineListener : public EventEngine::Listener {
+class WindowsEventEngineListener
+    : public ExtendedType<
+          EventEngine::Listener,
+          grpc_event_engine::experimental::IomgrCompatibleListener> {
  public:
   WindowsEventEngineListener(
       IOCP* iocp, AcceptCallback accept_cb,
@@ -51,9 +56,9 @@ class WindowsEventEngineListener : public EventEngine::Listener {
   ~WindowsEventEngineListener() override;
   absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr) override;
   absl::Status Start() override;
-  // TODO(hork): this may only be needed for the iomgr shim, to accommodate
-  // calls to grpc_tcp_server_shutdown_listeners
-  void ShutdownListeners();
+
+  // Part of IomgrCompatibleListener
+  void Shutdown() override;
 
  private:
   /// Responsible for listening on a single port.