grpc 1.53.0 → 1.59.2

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.cc

@@ -27,9 +27,11 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/channel_arg_names.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
@@ -96,8 +98,21 @@ absl::Status ErrorForFd(
 
 int CreateSocket(std::function<int(int, int, int)> socket_factory, int family,
                  int type, int protocol) {
-  return socket_factory != nullptr ? socket_factory(family, type, protocol)
-                                   : socket(family, type, protocol);
+  int res = socket_factory != nullptr ? socket_factory(family, type, protocol)
+                                      : socket(family, type, protocol);
+  if (res < 0 && errno == EMFILE) {
+    int saved_errno = errno;
+    GRPC_LOG_EVERY_N_SEC(
+        10, GPR_ERROR,
+        "socket(%d, %d, %d) returned %d with error: |%s|. This process "
+        "might not have a sufficient file descriptor limit for the number "
+        "of connections grpc wants to open (which is generally a function of "
+        "the number of grpc channels, the lb policy of each channel, and the "
+        "number of backends each channel is load balancing across).",
+        family, type, protocol, res, grpc_core::StrError(errno).c_str());
+    errno = saved_errno;
+  }
+  return res;
 }
 
 absl::Status PrepareTcpClientSocket(PosixSocketWrapper sock,
@@ -111,11 +126,14 @@ absl::Status PrepareTcpClientSocket(PosixSocketWrapper sock,
   });
   GRPC_RETURN_IF_ERROR(sock.SetSocketNonBlocking(1));
   GRPC_RETURN_IF_ERROR(sock.SetSocketCloexec(1));
-
-  if (reinterpret_cast<const sockaddr*>(addr.address())->sa_family != AF_UNIX) {
-    // If its not a unix socket address.
+  if (options.tcp_receive_buffer_size != options.kReadBufferSizeUnset) {
+    GRPC_RETURN_IF_ERROR(sock.SetSocketRcvBuf(options.tcp_receive_buffer_size));
+  }
+  if (addr.address()->sa_family != AF_UNIX && !ResolvedAddressIsVSock(addr)) {
+    // If its not a unix socket or vsock address.
     GRPC_RETURN_IF_ERROR(sock.SetSocketLowLatency(1));
     GRPC_RETURN_IF_ERROR(sock.SetSocketReuseAddr(1));
+    GRPC_RETURN_IF_ERROR(sock.SetSocketDscp(options.dscp));
     sock.TrySetSocketTcpUserTimeout(options, true);
   }
   GRPC_RETURN_IF_ERROR(sock.SetSocketNoSigpipeIfPossible());
@@ -126,6 +144,11 @@ absl::Status PrepareTcpClientSocket(PosixSocketWrapper sock,
   return absl::OkStatus();
 }
 
+bool SetSocketDualStack(int fd) {
+  const int off = 0;
+  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
+}
+
 #endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
 
 }  // namespace
@@ -150,6 +173,9 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
   options.tcp_tx_zerocopy_max_simultaneous_sends =
       AdjustValue(PosixTcpOptions::kDefaultMaxSends, 0, INT_MAX,
                   config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS));
+  options.tcp_receive_buffer_size =
+      AdjustValue(PosixTcpOptions::kReadBufferSizeUnset, 0, INT_MAX,
+                  config.GetInt(GRPC_ARG_TCP_RECEIVE_BUFFER_SIZE));
   options.tcp_tx_zero_copy_enabled =
       (AdjustValue(PosixTcpOptions::kZerocpTxEnabledDefault, 0, 1,
                    config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED)) != 0);
@@ -160,6 +186,8 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
   options.expand_wildcard_addrs =
       (AdjustValue(0, 1, INT_MAX,
                    config.GetInt(GRPC_ARG_EXPAND_WILDCARD_ADDRS)) != 0);
+  options.dscp = AdjustValue(PosixTcpOptions::kDscpNotSet, 0, 63,
+                             config.GetInt(GRPC_ARG_DSCP));
   options.allow_reuse_port = PosixSocketWrapper::IsSocketReusePortSupported();
   auto allow_reuse_port_value = config.GetInt(GRPC_ARG_ALLOW_REUSEPORT);
   if (allow_reuse_port_value.has_value()) {
@@ -495,6 +523,39 @@ absl::Status PosixSocketWrapper::SetSocketLowLatency(int low_latency) {
   return absl::OkStatus();
 }
 
+// Set Differentiated Services Code Point (DSCP)
+absl::Status PosixSocketWrapper::SetSocketDscp(int dscp) {
+  if (dscp == PosixTcpOptions::kDscpNotSet) {
+    return absl::OkStatus();
+  }
+  // The TOS/TrafficClass byte consists of following bits:
+  // | 7 6 5 4 3 2 | 1 0 |
+  // |    DSCP     | ECN |
+  int newval = dscp << 2;
+  int val;
+  socklen_t intlen = sizeof(val);
+  // Get ECN bits from current IP_TOS value unless IPv6 only
+  if (0 == getsockopt(fd_, IPPROTO_IP, IP_TOS, &val, &intlen)) {
+    newval |= (val & 0x3);
+    if (0 != setsockopt(fd_, IPPROTO_IP, IP_TOS, &newval, sizeof(newval))) {
+      return absl::Status(
+          absl::StatusCode::kInternal,
+          absl::StrCat("setsockopt(IP_TOS): ", grpc_core::StrError(errno)));
+    }
+  }
+  // Get ECN from current Traffic Class value if IPv6 is available
+  if (0 == getsockopt(fd_, IPPROTO_IPV6, IPV6_TCLASS, &val, &intlen)) {
+    newval |= (val & 0x3);
+    if (0 !=
+        setsockopt(fd_, IPPROTO_IPV6, IPV6_TCLASS, &newval, sizeof(newval))) {
+      return absl::Status(absl::StatusCode::kInternal,
+                          absl::StrCat("setsockopt(IPV6_TCLASS): ",
+                                       grpc_core::StrError(errno)));
+    }
+  }
+  return absl::OkStatus();
+}
+
 #if GPR_LINUX == 1
 // For Linux, it will be detected to support TCP_USER_TIMEOUT
 #ifndef TCP_USER_TIMEOUT
@@ -606,11 +667,6 @@ absl::Status PosixSocketWrapper::ApplySocketMutatorInOptions(
   return SetSocketMutator(usage, options.socket_mutator);
 }
 
-bool PosixSocketWrapper::SetSocketDualStack() {
-  const int off = 0;
-  return 0 == setsockopt(fd_, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
-}
-
 bool PosixSocketWrapper::IsIpv6LoopbackAvailable() {
   static bool kIpv6LoopbackAvailable = []() -> bool {
     int fd = socket(AF_INET6, SOCK_STREAM, 0);
@@ -686,19 +742,18 @@ absl::StatusOr<PosixSocketWrapper> PosixSocketWrapper::CreateDualStackSocket(
       newfd = -1;
       errno = EAFNOSUPPORT;
     }
-    if (newfd < 0) {
-      return ErrorForFd(newfd, addr);
-    }
-    PosixSocketWrapper sock(newfd);
     // Check if we've got a valid dualstack socket.
-    if (sock.SetSocketDualStack()) {
+    if (newfd > 0 && SetSocketDualStack(newfd)) {
       dsmode = PosixSocketWrapper::DSMode::DSMODE_DUALSTACK;
-      return sock;
+      return PosixSocketWrapper(newfd);
     }
     // If this isn't an IPv4 address, then return whatever we've got.
     if (!ResolvedAddressIsV4Mapped(addr, nullptr)) {
+      if (newfd < 0) {
+        return ErrorForFd(newfd, addr);
+      }
       dsmode = PosixSocketWrapper::DSMode::DSMODE_IPV6;
-      return sock;
+      return PosixSocketWrapper(newfd);
     }
     // Fall back to AF_INET.
     if (newfd >= 0) {
@@ -781,6 +836,10 @@ absl::Status PosixSocketWrapper::SetSocketReusePort(int /*reuse*/) {
   grpc_core::Crash("unimplemented");
 }
 
+absl::Status PosixSocketWrapper::SetSocketDscp(int /*dscp*/) {
+  grpc_core::Crash("unimplemented");
+}
+
 void PosixSocketWrapper::ConfigureDefaultTcpUserTimeout(bool /*enable*/,
                                                         int /*timeout*/,
                                                         bool /*is_client*/) {}
@@ -820,10 +879,6 @@ absl::Status PosixSocketWrapper::ApplySocketMutatorInOptions(
   grpc_core::Crash("unimplemented");
 }
 
-bool PosixSocketWrapper::SetSocketDualStack() {
-  grpc_core::Crash("unimplemented");
-}
-
 bool PosixSocketWrapper::IsSocketReusePortSupported() {
   grpc_core::Crash("unimplemented");
 }

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h

@@ -58,16 +58,21 @@ struct PosixTcpOptions {
   static constexpr int kMaxChunkSize = 32 * 1024 * 1024;
   static constexpr int kDefaultMaxSends = 4;
   static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
+  // Let the system decide the proper buffer size.
+  static constexpr int kReadBufferSizeUnset = -1;
+  static constexpr int kDscpNotSet = -1;
   int tcp_read_chunk_size = kDefaultReadChunkSize;
   int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
   int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
   int tcp_tx_zerocopy_send_bytes_threshold = kDefaultSendBytesThreshold;
   int tcp_tx_zerocopy_max_simultaneous_sends = kDefaultMaxSends;
+  int tcp_receive_buffer_size = kReadBufferSizeUnset;
   bool tcp_tx_zero_copy_enabled = kZerocpTxEnabledDefault;
   int keep_alive_time_ms = 0;
   int keep_alive_timeout_ms = 0;
   bool expand_wildcard_addrs = false;
   bool allow_reuse_port = false;
+  int dscp = kDscpNotSet;
   grpc_core::RefCountedPtr<grpc_core::ResourceQuota> resource_quota;
   struct grpc_socket_mutator* socket_mutator = nullptr;
   PosixTcpOptions() = default;
@@ -132,6 +137,7 @@ struct PosixTcpOptions {
     keep_alive_timeout_ms = other.keep_alive_timeout_ms;
     expand_wildcard_addrs = other.expand_wildcard_addrs;
     allow_reuse_port = other.allow_reuse_port;
+    dscp = other.dscp;
   }
 };
 
@@ -179,6 +185,9 @@ class PosixSocketWrapper {
   // Set SO_REUSEPORT
   absl::Status SetSocketReusePort(int reuse);
 
+  // Set Differentiated Services Code Point (DSCP)
+  absl::Status SetSocketDscp(int dscp);
+
   // Override default Tcp user timeout values if necessary.
   void TrySetSocketTcpUserTimeout(const PosixTcpOptions& options,
                                   bool is_client);
@@ -238,9 +247,6 @@ class PosixSocketWrapper {
     DSMODE_DUALSTACK
   };
 
-  // Tries to set the socket to dualstack. Returns true on success.
-  bool SetSocketDualStack();
-
   // Returns the underlying file-descriptor.
   int Fd() const { return fd_; }
 

data/src/core/lib/event_engine/posix_engine/timer.h

@@ -77,46 +77,19 @@ class TimerList {
   TimerList(const TimerList&) = delete;
   TimerList& operator=(const TimerList&) = delete;
 
-  // Initialize *timer. When expired or canceled, closure will be called with
-  // error set to indicate if it expired (absl::OkStatus()) or was canceled
-  //(absl::CancelledError()). *closure is guaranteed to be called exactly once,
-  // and application code should check the error to determine how it was
-  // invoked. The application callback is also responsible for maintaining
-  // information about when to free up any user-level state. Behavior is
-  // undefined for a deadline of grpc_core::Timestamp::InfFuture().
+  // Initialize a Timer.
+  // When expired, the closure will be run. If the timer is canceled, the
+  // closure will not be run. Behavior is undefined for a deadline of
+  // grpc_core::Timestamp::InfFuture().
   void TimerInit(Timer* timer, grpc_core::Timestamp deadline,
                  experimental::EventEngine::Closure* closure);
 
-  // Note that there is no timer destroy function. This is because the
-  // timer is a one-time occurrence with a guarantee that the callback will
-  // be called exactly once, either at expiration or cancellation. Thus, all
-  // the internal timer event management state is destroyed just before
-  // that callback is invoked. If the user has additional state associated with
-  // the timer, the user is responsible for determining when it is safe to
-  // destroy that state.
-
-  // Cancel an *timer.
-  // There are three cases:
-  // 1. We normally cancel the timer
-  // 2. The timer has already run
-  // 3. We can't cancel the timer because it is "in flight".
-
-  // In all of these cases, the cancellation is still considered successful.
-  // They are essentially distinguished in that the timer_cb will be run
-  // exactly once from either the cancellation (with error
-  // absl::CancelledError()) or from the activation (with error
-  // absl::OkStatus()).
-
-  // Note carefully that the callback function MAY occur in the same callstack
-  // as grpc_timer_cancel. It's expected that most timers will be cancelled
-  // (their primary use is to implement deadlines), and so this code is
-  // optimized such that cancellation costs as little as possible. Making
-  // callbacks run inline matches this aim.
-
-  // Requires: cancel() must happen after init() on a given timer
-  bool TimerCancel(Timer* timer) GRPC_MUST_USE_RESULT;
-
-  // iomgr internal api for dealing with timers
+  // Cancel a Timer.
+  // Returns false if the timer cannot be canceled. This will happen if the
+  // timer has already fired, or if its closure is currently running. The
+  // closure is guaranteed to run eventually if this method returns false.
+  // Otherwise, this returns true, and the closure will not be run.
+  GRPC_MUST_USE_RESULT bool TimerCancel(Timer* timer);
 
   // Check for timers to be run, and return them.
   // Return nullopt if timers could not be checked due to contention with

data/src/core/lib/event_engine/posix_engine/timer_manager.h

@@ -33,7 +33,7 @@
 
 #include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/posix_engine/timer.h"
-#include "src/core/lib/event_engine/thread_pool.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/gprpp/notification.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/thd.h"

data/src/core/lib/event_engine/posix_engine/traced_buffer_list.cc

@@ -279,6 +279,8 @@ void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
       elem = elem->next_;
       continue;
     }
+    g_timestamps_callback(elem->arg_, &(elem->ts_),
+                          absl::DeadlineExceededError("Ack timed out"));
     if (prev != nullptr) {
       prev->next_ = elem->next_;
       delete elem;

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

@@ -31,7 +31,8 @@ namespace experimental {
 EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
                                               socklen_t size)
     : size_(size) {
-  GPR_ASSERT(size <= sizeof(address_));
+  GPR_DEBUG_ASSERT(size >= 0);
+  GPR_ASSERT(static_cast<size_t>(size) <= sizeof(address_));
   memcpy(&address_, address, size);
 }
 

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

@@ -22,6 +22,12 @@
 namespace grpc_event_engine {
 namespace experimental {
 
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+bool g_event_engine_supports_fd = true;
+#else
+bool g_event_engine_supports_fd = false;
+#endif
+
 bool UseEventEngineClient() {
 // TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
 // available for other platforms.
@@ -29,6 +35,8 @@ bool UseEventEngineClient() {
   return grpc_core::IsEventEngineClientEnabled();
 #elif defined(GPR_WINDOWS)
   return grpc_core::IsEventEngineClientEnabled();
+#elif defined(GRPC_IOS_EVENT_ENGINE_CLIENT)
+  return true;
 #else
   return false;
 #endif
@@ -46,7 +54,7 @@ bool UseEventEngineListener() {
 
 bool EventEngineSupportsFd() {
 #if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
-  return true;
+  return g_event_engine_supports_fd;
 #else
   return false;
 #endif

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

@@ -36,6 +36,10 @@
 #include <sys/un.h>
 #endif
 
+#ifdef GRPC_HAVE_VSOCK
+#include <linux/vm_sockets.h>
+#endif
+
 #include <errno.h>
 #include <inttypes.h>
 #include <stdlib.h>
@@ -70,6 +74,10 @@ absl::StatusOr<std::string> GetScheme(
       return "ipv6";
     case AF_UNIX:
       return "unix";
+#ifdef GRPC_HAVE_VSOCK
+    case AF_VSOCK:
+      return "vsock";
+#endif
     default:
       return absl::InvalidArgumentError(
           absl::StrFormat("Unknown sockaddr family: %d",
@@ -92,12 +100,11 @@ absl::StatusOr<std::string> ResolvedAddrToUnixPathIfPossible(
 #else
   int len = resolved_addr->size() - sizeof(unix_addr->sun_family) - 1;
 #endif
-  bool abstract = (len < 0 || unix_addr->sun_path[0] == '\0');
+  if (len <= 0) return "";
   std::string path;
-  if (abstract) {
-    if (len >= 0) {
-      path = std::string(unix_addr->sun_path + 1, len);
-    }
+  if (unix_addr->sun_path[0] == '\0') {
+    // unix-abstract socket processing.
+    path = std::string(unix_addr->sun_path + 1, len);
     path = absl::StrCat(std::string(1, '\0'), path);
   } else {
     size_t maxlen = sizeof(unix_addr->sun_path);
@@ -115,9 +122,9 @@ absl::StatusOr<std::string> ResolvedAddrToUriUnixIfPossible(
   GRPC_RETURN_IF_ERROR(path.status());
   std::string scheme;
   std::string path_string;
-  if (path->at(0) == '\0') {
+  if (!path->empty() && path->at(0) == '\0' && path->length() > 1) {
     scheme = "unix-abstract";
-    path_string = path->length() > 1 ? path->substr(1, std::string::npos) : "";
+    path_string = path->substr(1, std::string::npos);
   } else {
     scheme = "unix";
     path_string = std::move(*path);
@@ -142,6 +149,39 @@ absl::StatusOr<std::string> ResolvedAddrToUriUnixIfPossible(
 }
 #endif
 
+#ifdef GRPC_HAVE_VSOCK
+absl::StatusOr<std::string> ResolvedAddrToVsockPathIfPossible(
+    const EventEngine::ResolvedAddress* resolved_addr) {
+  const sockaddr* addr = resolved_addr->address();
+  if (addr->sa_family != AF_VSOCK) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Socket family is not AF_VSOCK: ", addr->sa_family));
+  }
+  const sockaddr_vm* vm_addr = reinterpret_cast<const sockaddr_vm*>(addr);
+  return absl::StrCat(vm_addr->svm_cid, ":", vm_addr->svm_port);
+}
+
+absl::StatusOr<std::string> ResolvedAddrToUriVsockIfPossible(
+    const EventEngine::ResolvedAddress* resolved_addr) {
+  auto path = ResolvedAddrToVsockPathIfPossible(resolved_addr);
+  absl::StatusOr<grpc_core::URI> uri =
+      grpc_core::URI::Create("vsock", /*authority=*/"", std::move(*path),
+                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  if (!uri.ok()) return uri.status();
+  return uri->ToString();
+}
+#else
+absl::StatusOr<std::string> ResolvedAddrToVsockPathIfPossible(
+    const EventEngine::ResolvedAddress* /*resolved_addr*/) {
+  return absl::InvalidArgumentError("VSOCK is not supported.");
+}
+
+absl::StatusOr<std::string> ResolvedAddrToUriVsockIfPossible(
+    const EventEngine::ResolvedAddress* /*resolved_addr*/) {
+  return absl::InvalidArgumentError("VSOCK is not supported.");
+}
+#endif
+
 }  // namespace
 
 bool ResolvedAddressIsV4Mapped(
@@ -232,6 +272,10 @@ int ResolvedAddressGetPort(const EventEngine::ResolvedAddress& resolved_addr) {
 #ifdef GRPC_HAVE_UNIX_SOCKET
     case AF_UNIX:
       return 1;
+#endif
+#ifdef GRPC_HAVE_VSOCK
+    case AF_VSOCK:
+      return 1;
 #endif
     default:
       gpr_log(GPR_ERROR, "Unknown socket family %d in ResolvedAddressGetPort",
@@ -292,6 +336,15 @@ absl::optional<int> ResolvedAddressIsWildcard(
   }
 }
 
+bool ResolvedAddressIsVSock(const EventEngine::ResolvedAddress& resolved_addr) {
+#ifdef GRPC_HAVE_VSOCK
+  return resolved_addr.address()->sa_family == AF_VSOCK;
+#else
+  (void)resolved_addr;
+  return false;
+#endif
+}
+
 absl::StatusOr<std::string> ResolvedAddressToNormalizedString(
     const EventEngine::ResolvedAddress& resolved_addr) {
   EventEngine::ResolvedAddress addr_normalized;
@@ -312,6 +365,10 @@ absl::StatusOr<std::string> ResolvedAddressToString(
   }
 #endif  // GRPC_HAVE_UNIX_SOCKET
 
+  if (ResolvedAddressIsVSock(resolved_addr)) {
+    return ResolvedAddrToVsockPathIfPossible(&resolved_addr);
+  }
+
   const void* ip = nullptr;
   int port = 0;
   uint32_t sin6_scope_id = 0;
@@ -362,6 +419,9 @@ absl::StatusOr<std::string> ResolvedAddressToURI(
   if (*scheme == "unix") {
     return ResolvedAddrToUriUnixIfPossible(&addr);
   }
+  if (*scheme == "vsock") {
+    return ResolvedAddrToUriVsockIfPossible(&addr);
+  }
   auto path = ResolvedAddressToString(addr);
   GRPC_RETURN_IF_ERROR(path.status());
   absl::StatusOr<grpc_core::URI> uri =

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

@@ -61,6 +61,9 @@ void ResolvedAddressSetPort(EventEngine::ResolvedAddress& resolved_addr,
 absl::optional<int> ResolvedAddressIsWildcard(
     const EventEngine::ResolvedAddress& addr);
 
+// Returns true if resolved_addr is an VSOCK address. Otherwise returns false.
+bool ResolvedAddressIsVSock(const EventEngine::ResolvedAddress& resolved_addr);
+
 // Converts a EventEngine::ResolvedAddress into a newly-allocated
 // human-readable string.
 // Currently, only the AF_INET, AF_INET6, and AF_UNIX families are

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

@@ -0,0 +1,58 @@
+// Copyright 2023 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>
+
+#include "src/core/lib/event_engine/thread_pool/thread_count.h"
+
+#include <inttypes.h>
+
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+#include <grpc/support/log.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// -------- LivingThreadCount --------
+
+void LivingThreadCount::BlockUntilThreadCount(size_t desired_threads,
+                                              const char* why) {
+  constexpr grpc_core::Duration log_rate = grpc_core::Duration::Seconds(3);
+  while (true) {
+    auto curr_threads = WaitForCountChange(desired_threads, log_rate);
+    if (curr_threads == desired_threads) break;
+    GRPC_LOG_EVERY_N_SEC_DELAYED(
+        log_rate.seconds(), GPR_DEBUG,
+        "Waiting for thread pool to idle before %s. (%" PRIdPTR " to %" PRIdPTR
+        ")",
+        why, curr_threads, desired_threads);
+  }
+}
+
+size_t LivingThreadCount::WaitForCountChange(size_t desired_threads,
+                                             grpc_core::Duration timeout) {
+  size_t count;
+  auto deadline = absl::Now() + absl::Milliseconds(timeout.millis());
+  do {
+    grpc_core::MutexLock lock(&mu_);
+    count = CountLocked();
+    if (count == desired_threads) break;
+    cv_.WaitWithDeadline(&mu_, deadline);
+  } while (absl::Now() < deadline);
+  return count;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine