grpc 1.73.0 → 1.74.0

data/src/core/util/function_signature.h

@@ -42,23 +42,37 @@ namespace grpc_core {
 // for exporting debug/trace information.
 template <typename T>
 static constexpr inline absl::string_view TypeName() {
+#if ABSL_USES_STD_STRING_VIEW
+  // absl::string_view doesn't have the constexpr find methods we need
+  // here.
 #if defined(__clang__)
   constexpr absl::string_view kPrefix{"[T = "};
   constexpr absl::string_view kSuffix{"]"};
 #elif defined(__GNUC__)
+#if __GNUC__ < 9
+#define GRPC_FUNCTION_SIGNATURE_TYPE_NAME_USE_FALLBACK
+#endif
   constexpr absl::string_view kPrefix{"[with T = "};
   constexpr absl::string_view kSuffix{";"};
 #elif defined(_MSC_VER)
   constexpr absl::string_view kPrefix{"TypeName<"};
   constexpr absl::string_view kSuffix{">(void)"};
 #else
-  return "unknown";
+#define GRPC_FUNCTION_SIGNATURE_TYPE_NAME_USE_FALLBACK
 #endif
+#else  // !ABSL_USE_STD_STRING_VIEW
+#define GRPC_FUNCTION_SIGNATURE_TYPE_NAME_USE_FALLBACK
+#endif
+
+#ifdef GRPC_FUNCTION_SIGNATURE_TYPE_NAME_USE_FALLBACK
+  return "unknown";
+#else
   constexpr absl::string_view kFunction{GRPC_FUNCTION_SIGNATURE};
   constexpr size_t kStart = kFunction.find(kPrefix) + kPrefix.size();
   constexpr size_t kEnd = kFunction.rfind(kSuffix);
   static_assert(kStart < kEnd);
   return kFunction.substr(kStart, (kEnd - kStart));
+#endif
 }
 
 }  // namespace grpc_core

data/src/core/util/http_client/httpcli.cc

@@ -40,6 +40,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
@@ -175,7 +176,10 @@ HttpRequest::HttpRequest(
       pollent_(pollent),
       pollset_set_(grpc_pollset_set_create()),
       test_only_generate_response_(std::move(test_only_generate_response)),
-      use_event_engine_dns_resolver_(IsEventEngineDnsNonClientChannelEnabled()),
+      use_event_engine_dns_resolver_(
+          IsEventEngineDnsNonClientChannelEnabled() &&
+          !grpc_event_engine::experimental::
+              EventEngineExperimentDisabledForPython()),
       resolver_(!use_event_engine_dns_resolver_ ? GetDNSResolver() : nullptr),
       ee_resolver_(
           use_event_engine_dns_resolver_
@@ -196,8 +200,10 @@ HttpRequest::HttpRequest(
   GRPC_CLOSURE_INIT(&continue_done_write_after_schedule_on_exec_ctx_,
                     ContinueDoneWriteAfterScheduleOnExecCtx, this,
                     grpc_schedule_on_exec_ctx);
-  CHECK(pollent);
-  grpc_polling_entity_add_to_pollset_set(pollent, pollset_set_);
+  if (!grpc_event_engine::experimental::UsePollsetAlternative()) {
+    CHECK(pollent);
+    grpc_polling_entity_add_to_pollset_set(pollent, pollset_set_);
+  }
 }
 
 HttpRequest::~HttpRequest() {
@@ -329,8 +335,9 @@ void HttpRequest::StartWrite() {
   CSliceRef(request_text_);
   grpc_slice_buffer_add(&outgoing_, request_text_);
   Ref().release();  // ref held by pending write
-  grpc_endpoint_write(ep_.get(), &outgoing_, &done_write_, nullptr,
-                      /*max_frame_size=*/INT_MAX);
+  grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs args;
+  args.set_max_frame_size(INT_MAX);
+  grpc_endpoint_write(ep_.get(), &outgoing_, &done_write_, std::move(args));
 }
 
 void HttpRequest::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {

data/src/core/util/http_client/httpcli.h

@@ -35,6 +35,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "src/core/handshaker/handshaker.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
@@ -180,7 +181,9 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
  private:
   void Finish(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    grpc_polling_entity_del_from_pollset_set(pollent_, pollset_set_);
+    if (!grpc_event_engine::experimental::UsePollsetAlternative()) {
+      grpc_polling_entity_del_from_pollset_set(pollent_, pollset_set_);
+    }
     ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
   }
 

data/src/core/util/latent_see.h

@@ -47,7 +47,7 @@ namespace latent_see {
 struct Metadata {
   const char* file;
   int line;
-  const char* name;
+  absl::string_view name;
 };
 
 enum class EventType : uint8_t { kBegin, kEnd, kFlowStart, kFlowEnd, kMark };
@@ -259,6 +259,9 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Promise(const Metadata* md_poll,
 
 }  // namespace latent_see
 }  // namespace grpc_core
+#define GRPC_LATENT_SEE_SYMBOL2(name, line) name##_##line
+#define GRPC_LATENT_SEE_SYMBOL1(name, line) GRPC_LATENT_SEE_SYMBOL2(name, line)
+#define GRPC_LATENT_SEE_SYMBOL(name) GRPC_LATENT_SEE_SYMBOL1(name, __LINE__)
 #define GRPC_LATENT_SEE_METADATA(name)                                     \
   []() {                                                                   \
     static grpc_core::latent_see::Metadata metadata = {__FILE__, __LINE__, \
@@ -268,14 +271,14 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Promise(const Metadata* md_poll,
 // Parent scope: logs a begin and end event, and flushes the thread log on scope
 // exit. Because the flush takes some time it's better to place one parent scope
 // at the top of the stack, and use lighter weight scopes within it.
-#define GRPC_LATENT_SEE_PARENT_SCOPE(name)                       \
-  grpc_core::latent_see::ParentScope latent_see_scope##__LINE__( \
+#define GRPC_LATENT_SEE_PARENT_SCOPE(name)                                     \
+  grpc_core::latent_see::ParentScope GRPC_LATENT_SEE_SYMBOL(latent_see_scope)( \
       GRPC_LATENT_SEE_METADATA(name))
 // Inner scope: logs a begin and end event. Lighter weight than parent scope,
 // but does not flush the thread state - so should only be enclosed by a parent
 // scope.
-#define GRPC_LATENT_SEE_INNER_SCOPE(name)                       \
-  grpc_core::latent_see::InnerScope latent_see_scope##__LINE__( \
+#define GRPC_LATENT_SEE_INNER_SCOPE(name)                                     \
+  grpc_core::latent_see::InnerScope GRPC_LATENT_SEE_SYMBOL(latent_see_scope)( \
       GRPC_LATENT_SEE_METADATA(name))
 // Mark: logs a single event.
 // This is not flushed automatically, and so should only be used within a parent

data/src/core/util/log.cc

@@ -104,6 +104,7 @@ void gpr_log_verbosity_init(void) {
            "ERROR. However if you see this message in a debug environment or "
            "test environment it is safe to ignore this message.";
     absl::SetVLogLevel("*grpc*/*", -1);
+    absl::SetVLogLevel("src/core/util/log", -1);
     absl::SetMinLogLevel(absl::LogSeverityAtLeast::kInfo);
   } else if (absl::EqualsIgnoreCase(verbosity, "DEBUG")) {
     LOG_FIRST_N(WARNING, 1)
@@ -111,12 +112,15 @@ void gpr_log_verbosity_init(void) {
            "ERROR. However if you see this message in a debug environment or "
            "test environment it is safe to ignore this message.";
     absl::SetVLogLevel("*grpc*/*", 2);
+    absl::SetVLogLevel("src/core/util/log", 2);
     absl::SetMinLogLevel(absl::LogSeverityAtLeast::kInfo);
   } else if (absl::EqualsIgnoreCase(verbosity, "ERROR")) {
     absl::SetVLogLevel("*grpc*/*", -1);
+    absl::SetVLogLevel("src/core/util/log", -1);
     absl::SetMinLogLevel(absl::LogSeverityAtLeast::kError);
   } else if (absl::EqualsIgnoreCase(verbosity, "NONE")) {
     absl::SetVLogLevel("*grpc*/*", -1);
+    absl::SetVLogLevel("src/core/util/log", -1);
     absl::SetMinLogLevel(absl::LogSeverityAtLeast::kInfinity);
   } else if (verbosity.empty()) {
     // Do not alter absl settings if GRPC_VERBOSITY flag is not set.

data/src/core/util/memory_usage.h

@@ -0,0 +1,268 @@
+// Copyright 2025 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_UTIL_MEMORY_USAGE_H
+#define GRPC_SRC_CORE_UTIL_MEMORY_USAGE_H
+
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "src/core/util/time.h"
+
+namespace grpc_core {
+
+namespace memory_usage_detail {
+
+template <typename SfinaeVoid, typename T, typename... Args>
+struct IsBraceConstructible : public std::false_type {};
+
+template <typename T, typename... Args>
+struct IsBraceConstructible<std::void_t<decltype(T{std::declval<Args>()...})>,
+                            T, Args...> : public std::true_type {};
+
+template <typename T, typename... Args>
+constexpr bool kIsBraceConstructible =
+    IsBraceConstructible<void, T, Args...>::value;
+
+template <typename T>
+constexpr bool kAnyTypeConvertibleTo = true;
+template <typename T>
+constexpr bool kAnyTypeConvertibleTo<std::optional<T>> = false;
+
+struct AnyType {
+  template <typename T, std::enable_if_t<kAnyTypeConvertibleTo<T>, int> = 0>
+  // NOLINTNEXTLINE
+  constexpr operator T() {
+    LOG(FATAL) << "unreachable";
+  }
+};
+
+enum class Category {
+  kUncategorized,
+  kOptional,
+  kAbslStatusOr,
+  kSimple,        // memory usage == sizeof(T)
+  kOwnedPointer,  // memory usage is pointer + usage of pointed to value
+  kVector,        // memory usage is container + elements
+};
+
+template <typename T, typename = void>
+constexpr Category kMemoryUsageCategory = Category::kUncategorized;
+
+template <typename T>
+constexpr Category
+    kMemoryUsageCategory<T, std::enable_if_t<std::is_fundamental_v<T>>> =
+        Category::kSimple;
+
+template <typename T>
+constexpr Category
+    kMemoryUsageCategory<T, std::enable_if_t<std::is_enum_v<T>>> =
+        Category::kSimple;
+
+template <typename T, typename D>
+constexpr Category kMemoryUsageCategory<std::unique_ptr<T, D>> =
+    Category::kOwnedPointer;
+
+template <typename T>
+constexpr Category kMemoryUsageCategory<std::shared_ptr<T>> =
+    Category::kOwnedPointer;
+
+template <typename T>
+constexpr Category kMemoryUsageCategory<std::vector<T>> = Category::kVector;
+
+template <typename C, typename Traits, typename Allocator>
+constexpr Category
+    kMemoryUsageCategory<std::basic_string<C, Traits, Allocator>> =
+        Category::kVector;
+
+template <typename T>
+constexpr Category kMemoryUsageCategory<std::optional<T>> = Category::kOptional;
+
+template <typename T, typename = void>
+constexpr bool kHasMemoryUsageMethod = false;
+
+template <typename T>
+constexpr bool kHasMemoryUsageMethod<
+    T, std::void_t<decltype(std::declval<T>().MemoryUsage())>> = true;
+
+}  // namespace memory_usage_detail
+
+// Given an object x, `MemoryUsage(x)` returns a size_t that approximates the
+// memory used by x. It's not totally accurate, but "good enough" for systems
+// that need to roughly bound memory usage of a collection of elements.
+
+template <typename T>
+size_t MemoryUsageOf(const T& x) {
+  using memory_usage_detail::AnyType;
+  using memory_usage_detail::Category;
+  using memory_usage_detail::kHasMemoryUsageMethod;
+  using memory_usage_detail::kIsBraceConstructible;
+  constexpr Category category = memory_usage_detail::kMemoryUsageCategory<T>;
+  if constexpr (kHasMemoryUsageMethod<T>) {
+    return x.MemoryUsage();
+  } else if constexpr (std::is_empty_v<T>) {
+    return sizeof(T);
+  } else if constexpr (std::is_same_v<T, absl::Status>) {
+    if (x.ok()) return sizeof(T);
+    return 2 * sizeof(T) + x.message().length();  // wrong, but not super wrong
+  } else if constexpr (std::is_same_v<T, absl::Time>) {
+    return sizeof(T);
+  } else if constexpr (std::is_same_v<T, absl::string_view>) {
+    // Assume that the string_view is not owning the string.
+    return sizeof(T);
+  } else if constexpr (std::is_same_v<T, Timestamp>) {
+    return sizeof(T);
+  } else if constexpr (std::is_same_v<T, Duration>) {
+    return sizeof(T);
+  } else if constexpr (category == Category::kSimple) {
+    return sizeof(T);
+  } else if constexpr (category == Category::kOwnedPointer) {
+    if (x == nullptr) return sizeof(T);
+    return sizeof(T) + MemoryUsageOf(*x);
+  } else if constexpr (category == Category::kVector) {
+    size_t total = sizeof(T) + sizeof(*x.begin()) * (x.capacity() - x.size());
+    for (const auto& e : x) {
+      total += MemoryUsageOf(e);
+    }
+    return total;
+  } else if constexpr (category == Category::kOptional) {
+    if (x.has_value()) return MemoryUsageOf(*x) + sizeof(T) - sizeof(*x);
+    return sizeof(T);
+  } else if constexpr (category == Category::kAbslStatusOr) {
+    if (x.ok()) return MemoryUsageOf(*x) + sizeof(absl::Status);
+    return MemoryUsageOf(x.status()) + sizeof(T);
+  } else if constexpr (category == Category::kUncategorized) {
+    // Structs!
+    // If you have more than 8 fields, you can add more cases here.
+    // Keep sorted longest to shortest.
+    if constexpr (kIsBraceConstructible<T, AnyType, AnyType, AnyType, AnyType,
+                                        AnyType, AnyType, AnyType, AnyType,
+                                        AnyType, AnyType>) {
+      const auto& [v1, v2, v3, v4, v5, v6, v7, v8, v9, v10] = x;
+      constexpr auto padding = sizeof(T) - sizeof(v1) - sizeof(v2) -
+                               sizeof(v3) - sizeof(v4) - sizeof(v5) -
+                               sizeof(v6) - sizeof(v7) - sizeof(v8) -
+                               sizeof(v9) - sizeof(v10);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + MemoryUsageOf(v3) +
+             MemoryUsageOf(v4) + MemoryUsageOf(v5) + MemoryUsageOf(v6) +
+             MemoryUsageOf(v7) + MemoryUsageOf(v8) + MemoryUsageOf(v9) +
+             MemoryUsageOf(v10) + padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType, AnyType, AnyType,
+                                               AnyType, AnyType, AnyType,
+                                               AnyType, AnyType, AnyType>) {
+      const auto& [v1, v2, v3, v4, v5, v6, v7, v8, v9] = x;
+      constexpr auto padding =
+          sizeof(T) - sizeof(v1) - sizeof(v2) - sizeof(v3) - sizeof(v4) -
+          sizeof(v5) - sizeof(v6) - sizeof(v7) - sizeof(v8) - sizeof(v9);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + MemoryUsageOf(v3) +
+             MemoryUsageOf(v4) + MemoryUsageOf(v5) + MemoryUsageOf(v6) +
+             MemoryUsageOf(v7) + MemoryUsageOf(v8) + MemoryUsageOf(v9) +
+             padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType, AnyType, AnyType,
+                                               AnyType, AnyType, AnyType,
+                                               AnyType, AnyType>) {
+      const auto& [v1, v2, v3, v4, v5, v6, v7, v8] = x;
+      constexpr auto padding = sizeof(T) - sizeof(v1) - sizeof(v2) -
+                               sizeof(v3) - sizeof(v4) - sizeof(v5) -
+                               sizeof(v6) - sizeof(v7) - sizeof(v8);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + MemoryUsageOf(v3) +
+             MemoryUsageOf(v4) + MemoryUsageOf(v5) + MemoryUsageOf(v6) +
+             MemoryUsageOf(v7) + MemoryUsageOf(v8) + padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType, AnyType, AnyType,
+                                               AnyType, AnyType, AnyType,
+                                               AnyType>) {
+      const auto& [v1, v2, v3, v4, v5, v6, v7] = x;
+      constexpr auto padding = sizeof(T) - sizeof(v1) - sizeof(v2) -
+                               sizeof(v3) - sizeof(v4) - sizeof(v5) -
+                               sizeof(v6) - sizeof(v7);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + MemoryUsageOf(v3) +
+             MemoryUsageOf(v4) + MemoryUsageOf(v5) + MemoryUsageOf(v6) +
+             MemoryUsageOf(v7) + padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType, AnyType, AnyType,
+                                               AnyType, AnyType, AnyType>) {
+      const auto& [v1, v2, v3, v4, v5, v6] = x;
+      constexpr auto padding = sizeof(T) - sizeof(v1) - sizeof(v2) -
+                               sizeof(v3) - sizeof(v4) - sizeof(v5) -
+                               sizeof(v6);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + MemoryUsageOf(v3) +
+             MemoryUsageOf(v4) + MemoryUsageOf(v5) + MemoryUsageOf(v6) +
+             padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType, AnyType, AnyType,
+                                               AnyType, AnyType>) {
+      const auto& [v1, v2, v3, v4, v5] = x;
+      constexpr auto padding = sizeof(T) - sizeof(v1) - sizeof(v2) -
+                               sizeof(v3) - sizeof(v4) - sizeof(v5);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + MemoryUsageOf(v3) +
+             MemoryUsageOf(v4) + MemoryUsageOf(v5) + padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType, AnyType, AnyType,
+                                               AnyType>) {
+      const auto& [v1, v2, v3, v4] = x;
+      constexpr auto padding =
+          sizeof(T) - sizeof(v1) - sizeof(v2) - sizeof(v3) - sizeof(v4);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + MemoryUsageOf(v3) +
+             MemoryUsageOf(v4) + padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType, AnyType, AnyType>) {
+      const auto& [v1, v2, v3] = x;
+      constexpr auto padding = sizeof(T) - sizeof(v1) - sizeof(v2) - sizeof(v3);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + MemoryUsageOf(v3) +
+             padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType, AnyType>) {
+      const auto& [v1, v2] = x;
+      constexpr auto padding = sizeof(T) - sizeof(v1) - sizeof(v2);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + MemoryUsageOf(v2) + padding;
+    } else if constexpr (kIsBraceConstructible<T, AnyType>) {
+      const auto& [v1] = x;
+      constexpr auto padding = sizeof(T) - sizeof(v1);
+      static_assert(padding >= 0);
+      return MemoryUsageOf(v1) + padding;
+    } else {
+      // Probably wrong, but we've not figured any better...
+      LOG(DFATAL) << "Unsupported type";
+      return sizeof(T);
+    }
+  } else {
+    // Probably wrong, but we've not figured any better...
+    LOG(DFATAL) << "Unsupported type";
+    return sizeof(T);
+  }
+}
+
+template <typename... Args>
+size_t MemoryUsageOf(const std::tuple<Args...>& t) {
+  return std::apply(
+      [](const auto&... args) { return (MemoryUsageOf(args) + ... + 0); }, t);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_MEMORY_USAGE_H

data/src/core/util/per_cpu.cc

@@ -21,7 +21,9 @@
 
 namespace grpc_core {
 
+#ifndef GPR_CPU_CUSTOM
 thread_local PerCpuShardingHelper::State PerCpuShardingHelper::state_;
+#endif  // GPR_CPU_CUSTOM
 
 size_t PerCpuOptions::Shards() {
   return ShardsForCpuCount(gpr_cpu_num_cores());

data/src/core/util/per_cpu.h

@@ -55,6 +55,12 @@ class PerCpuOptions {
   size_t max_shards_ = std::numeric_limits<size_t>::max();
 };
 
+#ifdef GPR_CPU_CUSTOM
+class PerCpuShardingHelper {
+ public:
+  size_t GetShardingBits() { return gpr_cpu_current_cpu(); }
+};
+#else
 class PerCpuShardingHelper {
  public:
   size_t GetShardingBits() {
@@ -76,6 +82,7 @@ class PerCpuShardingHelper {
   };
   static thread_local State state_;
 };
+#endif  // GPR_CPU_CUSTOM
 
 template <typename T>
 class PerCpu {

data/src/core/util/shared_bit_gen.h

@@ -19,6 +19,25 @@
 
 namespace grpc_core {
 
+#if defined(GRPC_CPU_INTENSIVE_BITGEN)
+class SharedBitGen {
+ public:
+  SharedBitGen() = default;
+  SharedBitGen(const SharedBitGen&) = delete;
+  SharedBitGen& operator=(const SharedBitGen&) = delete;
+  SharedBitGen(SharedBitGen&&) = default;
+  SharedBitGen& operator=(SharedBitGen&&) = default;
+
+  using result_type = absl::BitGen::result_type;
+  result_type operator()() { return bit_gen_(); }
+
+  static constexpr auto min() { return absl::BitGen::min(); }
+  static constexpr auto max() { return absl::BitGen::max(); }
+
+ private:
+  absl::BitGen bit_gen_;
+};
+#else
 class SharedBitGen {
  public:
   SharedBitGen() = default;
@@ -38,6 +57,7 @@ class SharedBitGen {
   // for the mutex acquisition.
   static thread_local absl::BitGen bit_gen_;
 };
+#endif  // defined(GRPC_CPU_INTENSIVE_BITGEN)
 
 }  // namespace grpc_core
 

data/src/core/util/single_set_ptr.h

@@ -105,13 +105,13 @@ class SingleSetRefCountedPtr {
 
   T& operator*() const { return *Get(); }
 
+  T* Set(RefCountedPtr<T> p) { return p_.Set(p.release()); }
+
  private:
   struct UnrefDeleter {
     void operator()(T* p) { p->Unref(); }
   };
 
-  T* Set(RefCountedPtr<T> p) { return p_.Set(p.release()); }
-
   SingleSetPtr<T, UnrefDeleter> p_;
 };
 

data/src/core/util/upb_utils.h

@@ -17,10 +17,15 @@
 #ifndef GRPC_SRC_CORE_UTIL_UPB_UTILS_H
 #define GRPC_SRC_CORE_UTIL_UPB_UTILS_H
 
+#include <grpc/support/time.h>
+
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "google/protobuf/duration.upb.h"
+#include "google/protobuf/timestamp.upb.h"
 #include "upb/base/string_view.h"
+#include "upb/mem/arena.h"
 
 namespace grpc_core {
 
@@ -30,6 +35,17 @@ inline upb_StringView StdStringToUpbString(const T& str) {
   return upb_StringView_FromDataAndSize(str.data(), str.size());
 }
 
+inline upb_StringView StdStringToUpbString(const char* str) {
+  return upb_StringView_FromDataAndSize(str, strlen(str));
+}
+
+template <typename T>
+inline upb_StringView CopyStdStringToUpbString(const T& str, upb_Arena* arena) {
+  char* copy = static_cast<char*>(upb_Arena_Malloc(arena, str.size()));
+  memcpy(copy, str.data(), str.size());
+  return upb_StringView_FromDataAndSize(copy, str.size());
+}
+
 inline absl::string_view UpbStringToAbsl(const upb_StringView& str) {
   return absl::string_view(str.data, str.size);
 }
@@ -38,6 +54,32 @@ inline std::string UpbStringToStdString(const upb_StringView& str) {
   return std::string(str.data, str.size);
 }
 
+inline void TimestampToUpb(gpr_timespec ts, google_protobuf_Timestamp* proto) {
+  auto t = gpr_convert_clock_type(ts, GPR_CLOCK_REALTIME);
+  google_protobuf_Timestamp_set_seconds(proto, t.tv_sec);
+  google_protobuf_Timestamp_set_nanos(proto, t.tv_nsec);
+}
+
+inline void UpbToTimestamp(const google_protobuf_Timestamp* proto,
+                           gpr_timespec* ts) {
+  ts->clock_type = GPR_CLOCK_REALTIME;
+  ts->tv_sec = google_protobuf_Timestamp_seconds(proto);
+  ts->tv_nsec = google_protobuf_Timestamp_nanos(proto);
+}
+
+inline void DurationToUpb(gpr_timespec ts, google_protobuf_Duration* proto) {
+  auto t = gpr_convert_clock_type(ts, GPR_TIMESPAN);
+  google_protobuf_Duration_set_seconds(proto, t.tv_sec);
+  google_protobuf_Duration_set_nanos(proto, t.tv_nsec);
+}
+
+inline void UpbToTimestamp(const google_protobuf_Duration* proto,
+                           gpr_timespec* ts) {
+  ts->clock_type = GPR_TIMESPAN;
+  ts->tv_sec = google_protobuf_Duration_seconds(proto);
+  ts->tv_nsec = google_protobuf_Duration_nanos(proto);
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_UPB_UTILS_H

data/src/core/util/uri.cc

@@ -259,7 +259,7 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
   std::string host_port;
   if (absl::ConsumePrefix(&remaining, "//")) {
     offset = remaining.find_first_of("/?#");
-    absl::string_view encoded_authority = (remaining.substr(0, offset));
+    absl::string_view encoded_authority = remaining.substr(0, offset);
     // parse user_info and host_port
     absl::string_view encoded_user_info;
     absl::string_view encoded_host_port;
@@ -404,7 +404,8 @@ std::string URI::ToString() const {
   std::vector<std::string> parts = {PercentEncode(scheme_, IsSchemeChar), ":"};
   // If path starts with '//' we need to encode the authority to ensure that
   // we can round-trip the URI through a parse/encode/parse loop.
-  if (!host_port_.empty() || absl::StartsWith(path_, "//")) {
+  if (!user_info_.empty() || !host_port_.empty() ||
+      absl::StartsWith(path_, "//")) {
     parts.emplace_back("//");
     if (!user_info_.empty()) {
       parts.emplace_back(PercentEncode(user_info_, IsUserInfoChar));

data/src/core/util/useful.h

@@ -19,6 +19,7 @@
 
 #include <cstddef>
 #include <limits>
+#include <type_traits>
 #include <variant>
 
 #include "absl/log/check.h"
@@ -114,8 +115,58 @@ inline T SaturatingAdd(T a, T b) {
   return a + b;
 }
 
-inline uint32_t MixHash32(uint32_t a, uint32_t b) {
-  return absl::rotl(a, 2u) ^ b;
+template <
+    typename T,
+    std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T>, int> = 0>
+inline T SaturatingMul(T a, T b) {
+  if (a == 0 || b == 0) return 0;
+  if (b > std::numeric_limits<T>::max() / a) {
+    return std::numeric_limits<T>::max();
+  }
+  return a * b;
+}
+
+template <
+    typename T,
+    std::enable_if_t<std::is_integral_v<T> && std::is_signed_v<T>, int> = 0>
+inline T SaturatingMul(T a, T b) {
+  if (a == 0 || b == 0) return 0;
+  if (a == std::numeric_limits<T>::min()) {
+    // negation is ub
+    if (b == -1) return std::numeric_limits<T>::max();
+    if (b == 1) return std::numeric_limits<T>::min();
+    if (b > 1) return std::numeric_limits<T>::min();
+    return std::numeric_limits<T>::max();
+  }
+  if (b == std::numeric_limits<T>::min()) {
+    if (a == -1) return std::numeric_limits<T>::max();
+    if (a == 1) return std::numeric_limits<T>::min();
+    if (a > 1) return std::numeric_limits<T>::min();
+    return std::numeric_limits<T>::max();
+  }
+  if (a > 0 && b > 0) {
+    // both positive
+    if (a > std::numeric_limits<T>::max() / b) {
+      return std::numeric_limits<T>::max();
+    }
+  } else if (a < 0 && b < 0) {
+    // both negative
+    if (a < std::numeric_limits<T>::max() / b) {
+      return std::numeric_limits<T>::max();
+    }
+  } else {
+    // one positive, one negative
+    if (a > 0) {
+      if (b < std::numeric_limits<T>::min() / a) {
+        return std::numeric_limits<T>::min();
+      }
+    } else {
+      if (a < std::numeric_limits<T>::min() / b) {
+        return std::numeric_limits<T>::min();
+      }
+    }
+  }
+  return a * b;
 }
 
 inline uint32_t RoundUpToPowerOf2(uint32_t v) {