grpc 1.73.0 → 1.75.0

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

@@ -90,9 +90,10 @@ class SingleSetRefCountedPtr {
 
   bool is_set() const { return p_.is_set(); }
 
-  RefCountedPtr<T> GetOrCreate() {
+  template <typename... Args>
+  RefCountedPtr<T> GetOrCreate(Args&&... args) {
     T* p = Get();
-    if (p == nullptr) p = Set(MakeRefCounted<T>());
+    if (p == nullptr) p = Set(MakeRefCounted<T>(std::forward<Args>(args)...));
     return p->Ref();
   }
   T* Get() const { return p_.Get(); }
@@ -105,13 +106,15 @@ class SingleSetRefCountedPtr {
 
   T& operator*() const { return *Get(); }
 
+  T* Set(RefCountedPtr<T> p) { return p_.Set(p.release()); }
+
+  void Reset() { p_.Reset(); }
+
  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) {
@@ -146,6 +197,97 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint64_t LowestOneBit(uint64_t x) {
   return x & -x;
 }
 
+namespace useful_detail {
+
+// Constexpr implementation of std::log for base e.
+// This is a simple implementation using a Taylor series expansion and may not
+// be as accurate as std::log from <cmath>. It is intended for use in constexpr
+// contexts.
+// It uses the identity log(y) = 2 * atanh((y-1)/(y+1))
+// where atanh(x) = x + x^3/3 + x^5/5 + ...
+constexpr double ConstexprLog(double y) {
+  if (y < 0) {
+    return std::numeric_limits<double>::quiet_NaN();
+  }
+  if (y == 0) {
+    return -std::numeric_limits<double>::infinity();
+  }
+  if (y == 1) {
+    return 0.0;
+  }
+  // Bring y into the range [1, 2) to improve convergence.
+  // log(y) = log(y / 2^k) + k*log(2)
+  int k = 0;
+  while (y > 2.0) {
+    y /= 2.0;
+    k++;
+  }
+  while (y < 1.0) {
+    y *= 2.0;
+    k--;
+  }
+  // Now y is in [1, 2).
+  // x = (y-1)/(y+1) is in [0, 1/3).
+  // The series will converge quickly.
+  double x = (y - 1) / (y + 1);
+  double x2 = x * x;
+  double term = x;
+  double sum = term;
+  for (int i = 1; i < 100; ++i) {
+    term *= x2;
+    double next_sum = sum + term / (2 * i + 1);
+    if (next_sum == sum) break;
+    sum = next_sum;
+  }
+  constexpr double kLog2 = 0.693147180559945309417;
+  return 2 * sum + k * kLog2;
+}
+
+// Constexpr implementation of std::exp.
+// This is a simple implementation using a Taylor series expansion and may not
+// be as accurate as std::exp from <cmath>. It is intended for use in constexpr
+// contexts.
+// It uses exp(x) = 1 + x + x^2/2! + x^3/3! + ...
+// For better convergence, we use range reduction via exp(x) = (exp(x/2))^2.
+constexpr double ConstexprExp(double x) {
+  if (x > 2.0 || x < -2.0) {
+    const double half = ConstexprExp(x / 2.0);
+    return half * half;
+  }
+  double sum = 1.0;
+  double term = 1.0;
+  for (int i = 1; i < 30; ++i) {
+    term *= x / i;
+    double next_sum = sum + term;
+    if (next_sum == sum) break;
+    sum = next_sum;
+  }
+  return sum;
+}
+
+}  // namespace useful_detail
+
+// Constexpr implementation of std::pow.
+// This is a simple implementation and may not be as accurate as std::pow from
+// <cmath>. It is intended for use in constexpr contexts.
+// Fuzztests exist in useful_fuzztest.cc to test that the constexpr and
+// non-constexpr implementations are within an acceptable error bound.
+// Replace with std::pow when we move to C++26.
+constexpr double ConstexprPow(double base, double exponent) {
+  // For simplicity, only handle non-negative bases.
+  // std::pow has more complex rules for negative bases.
+  if (base < 0) return std::numeric_limits<double>::quiet_NaN();
+  if (base == 0) {
+    if (exponent > 0) return 0.0;
+    if (exponent == 0) return 1.0;
+    return std::numeric_limits<double>::infinity();
+  }
+  if (exponent == 0.0) return 1.0;
+  if (exponent == 1.0) return base;
+  return useful_detail::ConstexprExp(exponent *
+                                     useful_detail::ConstexprLog(base));
+}
+
 }  // namespace grpc_core
 
 #define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))

data/src/core/util/wait_for_single_owner.cc

@@ -0,0 +1,31 @@
+// Copyright 2025 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 "src/core/util/wait_for_single_owner.h"
+
+#include "src/core/util/no_destruct.h"
+
+namespace grpc_core {
+
+NoDestruct<absl::AnyInvocable<void()>> cb_{nullptr};
+
+void SetWaitForSingleOwnerStalledCallback(absl::AnyInvocable<void()> cb) {
+  *cb_ = std::move(cb);
+}
+
+void WaitForSingleOwnerStalled() {
+  if (*cb_ != nullptr) (*cb_)();
+}
+
+}  // namespace grpc_core