grpc 1.56.2 → 1.58.0

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

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

@@ -0,0 +1,161 @@
+// 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.
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_COUNT_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_COUNT_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+#include <cstddef>
+#include <numeric>
+#include <utility>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+
+#include <grpc/support/cpu.h>
+
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Tracks counts across some fixed number of shards.
+// It is intended for fast increment/decrement operations, but a slower overall
+// count operation.
+class BusyThreadCount {
+ public:
+  // Increments a per-shard counter on construction, decrements on destruction.
+  class AutoThreadCounter {
+   public:
+    AutoThreadCounter(BusyThreadCount* counter, size_t idx)
+        : counter_(counter), idx_(idx) {
+      counter_->Increment(idx_);
+    }
+    ~AutoThreadCounter() {
+      if (counter_ != nullptr) counter_->Decrement(idx_);
+    }
+    // not copyable
+    AutoThreadCounter(const AutoThreadCounter&) = delete;
+    AutoThreadCounter& operator=(const AutoThreadCounter&) = delete;
+    // moveable
+    AutoThreadCounter(AutoThreadCounter&& other) noexcept {
+      counter_ = std::exchange(other.counter_, nullptr);
+      idx_ = other.idx_;
+    }
+    AutoThreadCounter& operator=(AutoThreadCounter&& other) noexcept {
+      counter_ = std::exchange(other.counter_, nullptr);
+      idx_ = other.idx_;
+      return *this;
+    }
+
+   private:
+    BusyThreadCount* counter_;
+    size_t idx_;
+  };
+
+  BusyThreadCount() : shards_(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 64u)) {}
+  AutoThreadCounter MakeAutoThreadCounter(size_t idx) {
+    return AutoThreadCounter(this, idx);
+  };
+  void Increment(size_t idx) {
+    shards_[idx].busy_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void Decrement(size_t idx) {
+    shards_[idx].busy_count.fetch_sub(1, std::memory_order_relaxed);
+  }
+  size_t count() {
+    return std::accumulate(
+        shards_.begin(), shards_.end(), 0, [](size_t running, ShardedData& d) {
+          return running + d.busy_count.load(std::memory_order_relaxed);
+        });
+  }
+  // Returns some valid index into the per-shard data, which is rotated on every
+  // call to distribute load and reduce contention.
+  size_t NextIndex() { return next_idx_.fetch_add(1) % shards_.size(); }
+
+ private:
+  struct ShardedData {
+    std::atomic<size_t> busy_count{0};
+  } GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
+
+  std::vector<ShardedData> shards_;
+  std::atomic<size_t> next_idx_{0};
+};
+
+// Tracks the number of living threads. It is intended for a fast count
+// operation, with relatively slower increment/decrement operations.
+class LivingThreadCount {
+ public:
+  // Increments the global counter on construction, decrements on destruction.
+  class AutoThreadCounter {
+   public:
+    explicit AutoThreadCounter(LivingThreadCount* counter) : counter_(counter) {
+      counter_->Increment();
+    }
+    ~AutoThreadCounter() {
+      if (counter_ != nullptr) counter_->Decrement();
+    }
+    // not copyable
+    AutoThreadCounter(const AutoThreadCounter&) = delete;
+    AutoThreadCounter& operator=(const AutoThreadCounter&) = delete;
+    // moveable
+    AutoThreadCounter(AutoThreadCounter&& other) noexcept {
+      counter_ = std::exchange(other.counter_, nullptr);
+    }
+    AutoThreadCounter& operator=(AutoThreadCounter&& other) noexcept {
+      counter_ = std::exchange(other.counter_, nullptr);
+      return *this;
+    }
+
+   private:
+    LivingThreadCount* counter_;
+  };
+
+  AutoThreadCounter MakeAutoThreadCounter() { return AutoThreadCounter(this); };
+  void Increment() ABSL_LOCKS_EXCLUDED(mu_) {
+    grpc_core::MutexLock lock(&mu_);
+    ++living_count_;
+    cv_.SignalAll();
+  }
+  void Decrement() ABSL_LOCKS_EXCLUDED(mu_) {
+    grpc_core::MutexLock lock(&mu_);
+    --living_count_;
+    cv_.SignalAll();
+  }
+  void BlockUntilThreadCount(size_t desired_threads, const char* why)
+      ABSL_LOCKS_EXCLUDED(mu_);
+  size_t count() ABSL_LOCKS_EXCLUDED(mu_) {
+    grpc_core::MutexLock lock(&mu_);
+    return CountLocked();
+  }
+
+ private:
+  size_t CountLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    return living_count_;
+  }
+  size_t WaitForCountChange(size_t desired_threads,
+                            grpc_core::Duration timeout);
+
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_ ABSL_GUARDED_BY(mu_);
+  size_t living_count_ ABSL_GUARDED_BY(mu_) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_COUNT_H

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

@@ -29,6 +29,13 @@ namespace grpc_event_engine {
 namespace experimental {
 
 std::shared_ptr<ThreadPool> MakeThreadPool(size_t reserve_threads) {
+// TODO(hork): remove when the listener flake is identified
+#ifdef GPR_WINDOWS
+  if (grpc_core::IsEventEngineListenerEnabled()) {
+    return std::make_shared<WorkStealingThreadPool>(
+        grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u));
+  }
+#endif
   if (grpc_core::IsWorkStealingEnabled()) {
     return std::make_shared<WorkStealingThreadPool>(
         grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u));