grpc 1.72.0 → 1.73.0

data/src/core/lib/promise/map.h

@@ -277,6 +277,18 @@ auto AddErrorPrefix(absl::string_view prefix, Promise promise) {
   });
 }
 
+template <typename Gen, typename Promise>
+auto AddGeneratedErrorPrefix(Gen prefix, Promise promise) {
+  return MapErrors(std::move(promise), [prefix](absl::Status status) {
+    absl::Status out(status.code(), absl::StrCat(prefix(), status.message()));
+    status.ForEachPayload(
+        [&out](absl::string_view name, const absl::Cord& value) {
+          out.SetPayload(name, value);
+        });
+    return out;
+  });
+}
+
 // Input : A promise that resolves to Type T
 // Returns : A Map promise which contains the input promise and then discards
 // the return value of the input promise. the main use case for DiscardResult is
@@ -305,12 +317,17 @@ template <typename Promise, typename... Values>
 auto TryStaple(Promise promise, Values&&... values) {
   return Map(
       std::move(promise),
-      [values = std::tuple(std::forward<Values>(values)...)](
-          auto first_value) mutable
-          -> absl::StatusOr<std::tuple<decltype(*first_value), Values...>> {
+      [values = std::tuple(std::forward<std::remove_reference_t<Values>>(
+           values)...)](auto first_value) mutable
+          -> absl::StatusOr<
+              std::tuple<std::remove_reference_t<decltype(*first_value)>,
+                         std::remove_reference_t<Values>...>> {
+        using FirstValueType = std::remove_reference_t<decltype(*first_value)>;
         if (!first_value.ok()) return first_value.status();
-        return std::tuple_cat(std::tuple(std::move(*first_value)),
-                              std::move(values));
+        return absl::StatusOr<
+            std::tuple<FirstValueType, std::remove_reference_t<Values>...>>(
+            std::tuple_cat(std::tuple<FirstValueType>(std::move(*first_value)),
+                           std::move(values)));
       });
 }
 

data/src/core/lib/promise/promise.h

@@ -24,6 +24,8 @@
 #include "absl/status/status.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/util/function_signature.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/seq.h

@@ -108,6 +108,8 @@ class Seq {
     return state_.PollOnce();
   }
 
+  Json ToJson() const { return state_.ToJson("Seq"); }
+
  private:
   SeqState<SeqTraits, P, Fs...> state_;
 };

data/src/core/lib/promise/sleep.cc

@@ -37,9 +37,12 @@ Sleep::~Sleep() {
 }
 
 Poll<absl::Status> Sleep::operator()() {
-  // Invalidate now so that we see a fresh version of the time.
-  // TODO(ctiller): the following can be safely removed when we remove ExecCtx.
-  ExecCtx::Get()->InvalidateNow();
+  if (!IsSleepPromiseExecCtxRemovalEnabled()) {
+    // Invalidate now so that we see a fresh version of the time.
+    // TODO(ctiller): the following can be safely removed when we remove
+    // ExecCtx.
+    ExecCtx::Get()->InvalidateNow();
+  }
   const auto now = Timestamp::Now();
   // If the deadline is earlier than now we can just return.
   if (deadline_ <= now) return absl::OkStatus();

data/src/core/lib/promise/try_seq.h

@@ -263,6 +263,8 @@ class TrySeq {
     return state_.PollOnce();
   }
 
+  Json ToJson() const { return state_.ToJson("TrySeq"); }
+
  private:
   SeqState<TrySeqTraits, P, Fs...> state_;
 };

data/src/core/lib/resource_quota/memory_quota.cc

@@ -152,6 +152,15 @@ ReclamationSweep::~ReclamationSweep() {
   }
 }
 
+void ReclamationSweep::Finish() {
+  auto memory_quota = std::move(memory_quota_);
+  if (memory_quota != nullptr) {
+    auto sweep_token = sweep_token_;
+    auto waker = std::move(waker_);
+    memory_quota->FinishReclamation(sweep_token, std::move(waker));
+  }
+}
+
 //
 // ReclaimerQueue
 //

data/src/core/lib/resource_quota/memory_quota.h

@@ -112,9 +112,7 @@ class ReclamationSweep {
   // Explicit finish for users that wish to write it.
   // Just destroying the object is enough, but sometimes the additional
   // explicitness is warranted.
-  void Finish() {
-    [](ReclamationSweep) {}(std::move(*this));
-  }
+  void Finish();
 
  private:
   std::shared_ptr<BasicMemoryQuota> memory_quota_;

data/src/core/lib/slice/slice_buffer.h

@@ -112,6 +112,12 @@ class SliceBuffer {
     grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
   }
 
+  /// Copy the first n bytes of the SliceBuffer into a memory pointed to by
+  /// dst. The original SliceBuffer remains unchanged.
+  void CopyFirstNBytesIntoBuffer(size_t n, void* dst) {
+    grpc_slice_buffer_copy_first_into_buffer(&slice_buffer_, n, dst);
+  }
+
   /// Removes/deletes the last n bytes in the SliceBuffer and add it to the
   /// other SliceBuffer
   void MoveLastNBytesIntoSliceBuffer(size_t n, SliceBuffer& other) {

data/src/core/lib/surface/call.cc

@@ -223,6 +223,10 @@ void Call::CancelWithStatus(grpc_status_code status, const char* description) {
         StatusIntProperty::kRpcStatus, status));
     return;
   }
+  if (status == GRPC_STATUS_OK) {
+    VLOG(2) << "CancelWithStatus() called with OK status, using UNKNOWN";
+    status = GRPC_STATUS_UNKNOWN;
+  }
   CancelWithError(
       absl::Status(static_cast<absl::StatusCode>(status), description));
 }

data/src/core/lib/surface/channel_create.cc

@@ -21,18 +21,24 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/log/check.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/client_channel/direct_channel.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/transport_credentials.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/lib/surface/legacy_channel.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/transport/endpoint_transport.h"
 
 namespace grpc_core {
 
@@ -72,10 +78,12 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
     channelz_node->AddTraceEvent(
         channelz::ChannelTrace::Severity::Info,
         grpc_slice_from_static_string("Channel created"));
+    channelz_node->SetChannelArgs(args);
     // Add channelz node to channel args.
     // We remove the is_internal_channel arg, since we no longer need it.
     args = args.Remove(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL)
-               .SetObject(std::move(channelz_node));
+               .SetObject<channelz::BaseNode>(channelz_node)
+               .SetObject(channelz_node);
   }
   // Add transport to args.
   if (optional_transport != nullptr) {
@@ -97,6 +105,36 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
   }
 }
 
+namespace {
+absl::StatusOr<grpc_channel*> CreateClientEndpointChannel(
+    const char* target, grpc_channel_credentials* creds,
+    const grpc_channel_args* c_args) {
+  const auto& c = CoreConfiguration::Get();
+  if (target == nullptr) {
+    return absl::InternalError("channel target is NULL");
+  }
+  if (creds == nullptr) return absl::InternalError("No credentials provided");
+  auto args = creds->update_arguments(c.channel_args_preconditioning()
+                                          .PreconditionChannelArgs(c_args)
+                                          .SetObject(creds->Ref()));
+  std::vector<absl::string_view> transport_preferences = absl::StrSplit(
+      args.GetString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS).value_or("h2"),
+      ',');
+  if (transport_preferences.size() != 1) {
+    return absl::InternalError(absl::StrCat(
+        "Only one preferred transport name is currently supported: requested='",
+        *args.GetOwnedString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS), "'"));
+  }
+  auto* transport =
+      c.endpoint_transport_registry().GetTransport(transport_preferences[0]);
+  if (transport == nullptr) {
+    return absl::InternalError(
+        absl::StrCat("Unknown transport '", transport_preferences[0], "'"));
+  }
+  return transport->ChannelCreate(target, args);
+}
+
+}  // namespace
 }  // namespace grpc_core
 
 grpc_channel* grpc_lame_client_channel_create(const char* target,
@@ -123,3 +161,25 @@ grpc_channel* grpc_lame_client_channel_create(const char* target,
   CHECK(channel.ok());
   return channel->release()->c_ptr();
 }
+
+// Create a client channel:
+//   Asynchronously: - resolve target
+//                   - connect to it (trying alternatives as presented)
+//                   - perform handshakes
+grpc_channel* grpc_channel_create(const char* target,
+                                  grpc_channel_credentials* creds,
+                                  const grpc_channel_args* c_args) {
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_channel_create(target=" << target << ", creds=" << (void*)creds
+      << ", args=" << (void*)c_args << ")";
+  auto r = grpc_core::CreateClientEndpointChannel(target, creds, c_args);
+  if (!r.ok()) {
+    return grpc_lame_client_channel_create(
+        target, static_cast<grpc_status_code>(r.status().code()),
+        absl::StrCat("Failed to create channel to '", target,
+                     "':", r.status().message())
+            .c_str());
+  }
+  return *r;
+}

data/src/core/lib/surface/init.cc

@@ -180,14 +180,14 @@ void grpc_shutdown(void) {
         !grpc_event_engine::experimental::TimerManager::
             IsTimerManagerThread() &&
         grpc_core::ExecCtx::Get() == nullptr) {
-      // just run clean-up when this is called on non-executor thread.
+      // just run clean-up when this is called on non-EventEngine thread.
       VLOG(2) << "grpc_shutdown starts clean-up now";
       g_shutting_down = true;
       grpc_shutdown_internal_locked();
       VLOG(2) << "grpc_shutdown done";
     } else {
       // spawn a detached thread to do the actual clean up in case we are
-      // currently in an executor thread.
+      // currently in an EventEngine thread.
       VLOG(2) << "grpc_shutdown spawns clean-up thread";
       g_initializations++;
       g_shutting_down = true;

data/src/core/lib/surface/version.cc

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "47.0.0"; }
+const char* grpc_version_string(void) { return "48.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gusto"; }
+const char* grpc_g_stands_for(void) { return "gradient"; }

data/src/core/lib/transport/status_conversion.cc

@@ -20,48 +20,21 @@
 
 #include <grpc/support/port_platform.h>
 
+using grpc_core::http2::AbslStatusCodeToErrorCode;
 using grpc_core::http2::Http2ErrorCode;
 
 Http2ErrorCode grpc_status_to_http2_error(grpc_status_code status) {
-  switch (status) {
-    case GRPC_STATUS_OK:
-      return Http2ErrorCode::kNoError;
-    case GRPC_STATUS_CANCELLED:
-      return Http2ErrorCode::kCancel;
-    case GRPC_STATUS_DEADLINE_EXCEEDED:
-      return Http2ErrorCode::kCancel;
-    case GRPC_STATUS_RESOURCE_EXHAUSTED:
-      return Http2ErrorCode::kEnhanceYourCalm;
-    case GRPC_STATUS_PERMISSION_DENIED:
-      return Http2ErrorCode::kInadequateSecurity;
-    case GRPC_STATUS_UNAVAILABLE:
-      return Http2ErrorCode::kRefusedStream;
-    default:
-      return Http2ErrorCode::kInternalError;
-  }
+  return AbslStatusCodeToErrorCode(static_cast<absl::StatusCode>(status));
 }
 
 grpc_status_code grpc_http2_error_to_grpc_status(
     Http2ErrorCode error, grpc_core::Timestamp deadline) {
-  switch (error) {
-    case Http2ErrorCode::kNoError:
-      // should never be received
-      return GRPC_STATUS_INTERNAL;
-    case Http2ErrorCode::kCancel:
-      // http2 cancel translates to STATUS_CANCELLED iff deadline hasn't been
-      // exceeded
-      return grpc_core::Timestamp::Now() > deadline
-                 ? GRPC_STATUS_DEADLINE_EXCEEDED
-                 : GRPC_STATUS_CANCELLED;
-    case Http2ErrorCode::kEnhanceYourCalm:
-      return GRPC_STATUS_RESOURCE_EXHAUSTED;
-    case Http2ErrorCode::kInadequateSecurity:
-      return GRPC_STATUS_PERMISSION_DENIED;
-    case Http2ErrorCode::kRefusedStream:
-      return GRPC_STATUS_UNAVAILABLE;
-    default:
-      return GRPC_STATUS_INTERNAL;
+  if (error == Http2ErrorCode::kNoError) {
+    // should never be received
+    return GRPC_STATUS_INTERNAL;
   }
+  return static_cast<grpc_status_code>(
+      ErrorCodeToAbslStatusCode(error, deadline));
 }
 
 grpc_status_code grpc_http2_status_to_grpc_status(int status) {

data/src/core/lib/transport/transport.cc

@@ -46,8 +46,8 @@ void grpc_stream_destroy(grpc_stream_refcount* refcount) {
     // If that's the case, destroying the call-stack MAY try to destroy the
     // thread, which is a tangled mess that we just don't want to ever have to
     // cope with.
-    // Throw this over to the executor (on a core-owned thread) and process it
-    // there.
+    // Throw this over to the EventEngine (on a core-owned thread) and process
+    // it there.
     grpc_event_engine::experimental::GetDefaultEventEngine()->Run([refcount] {
       grpc_core::ExecCtx exec_ctx;
       grpc_core::ExecCtx::Run(DEBUG_LOCATION, &refcount->destroy,

data/src/core/lib/transport/transport.h

@@ -42,6 +42,7 @@
 #include "src/core/call/message.h"
 #include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -559,6 +560,8 @@ class Transport : public InternallyRefCounted<Transport> {
     op->disconnect_with_error = error;
     PerformOp(op);
   }
+
+  virtual RefCountedPtr<channelz::SocketNode> GetSocketNode() const = 0;
 };
 
 class FilterStackTransport : public Transport {

data/src/core/load_balancing/backend_metric_parser.cc

@@ -31,23 +31,19 @@ namespace grpc_core {
 
 namespace {
 
-// TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto v30.0.
 std::map<absl::string_view, double> ParseMap(
     xds_data_orca_v3_OrcaLoadReport* msg,
-    const upb_Map* (*upb_map_func)(xds_data_orca_v3_OrcaLoadReport*),
+    bool (*upb_next_func)(const xds_data_orca_v3_OrcaLoadReport* msg,
+                          upb_StringView* key, double* val, size_t* iter),
     BackendMetricAllocatorInterface* allocator) {
-  const upb_Map* map = upb_map_func(msg);
   std::map<absl::string_view, double> result;
-  if (map) {
-    size_t i = kUpb_Map_Begin;
-    upb_MessageValue k, v;
-    while (upb_Map_Next(map, &k, &v, &i)) {
-      upb_StringView key_view = k.str_val;
-      double value = v.double_val;
-      char* key = allocator->AllocateString(key_view.size);
-      memcpy(key, key_view.data, key_view.size);
-      result[absl::string_view(key, key_view.size)] = value;
-    }
+  size_t i = kUpb_Map_Begin;
+  upb_StringView key_view;
+  double value;
+  while (upb_next_func(msg, &key_view, &value, &i)) {
+    char* key = allocator->AllocateString(key_view.size);
+    memcpy(key, key_view.data, key_view.size);
+    result[absl::string_view(key, key_view.size)] = value;
   }
   return result;
 }
@@ -73,14 +69,12 @@ const BackendMetricData* ParseBackendMetricData(
   backend_metric_data->qps =
       xds_data_orca_v3_OrcaLoadReport_rps_fractional(msg);
   backend_metric_data->eps = xds_data_orca_v3_OrcaLoadReport_eps(msg);
-  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
-  // v30.0.
   backend_metric_data->request_cost = ParseMap(
-      msg, _xds_data_orca_v3_OrcaLoadReport_request_cost_upb_map, allocator);
+      msg, xds_data_orca_v3_OrcaLoadReport_request_cost_next, allocator);
   backend_metric_data->utilization = ParseMap(
-      msg, _xds_data_orca_v3_OrcaLoadReport_utilization_upb_map, allocator);
+      msg, xds_data_orca_v3_OrcaLoadReport_utilization_next, allocator);
   backend_metric_data->named_metrics = ParseMap(
-      msg, _xds_data_orca_v3_OrcaLoadReport_named_metrics_upb_map, allocator);
+      msg, xds_data_orca_v3_OrcaLoadReport_named_metrics_next, allocator);
   return backend_metric_data;
 }
 

data/src/core/load_balancing/grpclb/grpclb.cc

@@ -1475,7 +1475,7 @@ void GrpcLb::ShutdownLocked() {
     if (parent_channelz_node_ != nullptr) {
       channelz::ChannelNode* child_channelz_node = lb_channel_->channelz_node();
       CHECK_NE(child_channelz_node, nullptr);
-      parent_channelz_node_->RemoveChildChannel(child_channelz_node->uuid());
+      child_channelz_node->RemoveParent(parent_channelz_node_.get());
     }
     lb_channel_.reset();
   }
@@ -1602,7 +1602,7 @@ absl::Status GrpcLb::UpdateBalancerChannelLocked() {
     channelz::ChannelNode* child_channelz_node = lb_channel_->channelz_node();
     auto parent_channelz_node = args_.GetObjectRef<channelz::ChannelNode>();
     if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
-      parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
+      child_channelz_node->AddParent(parent_channelz_node.get());
       parent_channelz_node_ = std::move(parent_channelz_node);
     }
   }

data/src/core/load_balancing/health_check_client.cc

@@ -282,11 +282,9 @@ class HealthProducer::ConnectivityWatcher final
   explicit ConnectivityWatcher(WeakRefCountedPtr<HealthProducer> producer)
       : producer_(std::move(producer)) {}
 
-  void OnConnectivityStateChange(
-      RefCountedPtr<ConnectivityStateWatcherInterface> self,
-      grpc_connectivity_state state, const absl::Status& status) override {
+  void OnConnectivityStateChange(grpc_connectivity_state state,
+                                 const absl::Status& status) override {
     producer_->OnConnectivityStateChange(state, status);
-    self.reset();
   }
 
   grpc_pollset_set* interested_parties() override {

data/src/core/load_balancing/oob_backend_metric.cc

@@ -72,11 +72,9 @@ class OrcaProducer::ConnectivityWatcher final
     grpc_pollset_set_destroy(interested_parties_);
   }
 
-  void OnConnectivityStateChange(
-      RefCountedPtr<ConnectivityStateWatcherInterface> self,
-      grpc_connectivity_state state, const absl::Status&) override {
+  void OnConnectivityStateChange(grpc_connectivity_state state,
+                                 const absl::Status&) override {
     producer_->OnConnectivityStateChange(state);
-    self.reset();
   }
 
   grpc_pollset_set* interested_parties() override {

data/src/core/load_balancing/outlier_detection/outlier_detection.cc

@@ -66,6 +66,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/validation_errors.h"
@@ -407,7 +408,6 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
     RefCountedPtr<OutlierDetectionLb> parent_;
     std::optional<EventEngine::TaskHandle> timer_handle_;
     Timestamp start_time_;
-    absl::BitGen bit_gen_;
   };
 
   ~OutlierDetectionLb() override;
@@ -924,7 +924,8 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
           << "] checking candidate " << endpoint_state
           << ": success_rate=" << success_rate;
       if (success_rate < ejection_threshold) {
-        uint32_t random_key = absl::Uniform(bit_gen_, 1, 100);
+        SharedBitGen bit_gen;
+        uint32_t random_key = absl::Uniform(bit_gen, 1, 100);
         double current_percent =
             100.0 * ejected_host_count / parent_->endpoint_state_map_.size();
         GRPC_TRACE_LOG(outlier_detection_lb, INFO)
@@ -967,7 +968,7 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
       if (endpoint_state->ejection_time().has_value()) continue;
       if ((100.0 - success_rate) >
           config.failure_percentage_ejection->threshold) {
-        uint32_t random_key = absl::Uniform(bit_gen_, 1, 100);
+        uint32_t random_key = absl::Uniform(SharedBitGen(), 1, 100);
         double current_percent =
             100.0 * ejected_host_count / parent_->endpoint_state_map_.size();
         GRPC_TRACE_LOG(outlier_detection_lb, INFO)

data/src/core/load_balancing/pick_first/pick_first.cc

@@ -61,6 +61,7 @@
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
 #include "src/core/util/work_serializer.h"
@@ -405,8 +406,6 @@ class PickFirst final : public LoadBalancingPolicy {
   grpc_connectivity_state state_ = GRPC_CHANNEL_CONNECTING;
   // Are we shut down?
   bool shutdown_ = false;
-  // Random bit generator used for shuffling addresses if configured
-  absl::BitGen bit_gen_;
 };
 
 PickFirst::PickFirst(Args args)
@@ -533,7 +532,8 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
       // Shuffle the list if needed.
       auto config = static_cast<PickFirstConfig*>(args.config.get());
       if (config->shuffle_addresses()) {
-        absl::c_shuffle(endpoints, bit_gen_);
+        SharedBitGen g;
+        absl::c_shuffle(endpoints, g);
       }
       // Flatten the list so that we have one address per endpoint.
       // While we're iterating, also determine the desired address family

data/src/core/load_balancing/rls/rls.cc

@@ -97,6 +97,7 @@
 #include "src/core/util/match.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
@@ -1557,7 +1558,7 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
     auto parent_channelz_node =
         lb_policy_->channel_args_.GetObjectRef<channelz::ChannelNode>();
     if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
-      parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
+      child_channelz_node->AddParent(parent_channelz_node.get());
       parent_channelz_node_ = std::move(parent_channelz_node);
     }
     // Start connectivity watch.
@@ -1578,7 +1579,7 @@ void RlsLb::RlsChannel::Orphan() {
     if (parent_channelz_node_ != nullptr) {
       channelz::ChannelNode* child_channelz_node = channel_->channelz_node();
       CHECK_NE(child_channelz_node, nullptr);
-      parent_channelz_node_->RemoveChildChannel(child_channelz_node->uuid());
+      child_channelz_node->RemoveParent(parent_channelz_node_.get());
     }
     // Stop connectivity watch.
     if (watcher_ != nullptr) {
@@ -1852,9 +1853,9 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
 
 std::string GenerateUUID() {
   absl::uniform_int_distribution<uint64_t> distribution;
-  absl::BitGen bitgen;
-  uint64_t hi = distribution(bitgen);
-  uint64_t lo = distribution(bitgen);
+  SharedBitGen g;
+  uint64_t hi = distribution(g);
+  uint64_t lo = distribution(g);
   return GenerateUUIDv4(hi, lo);
 }
 

data/src/core/load_balancing/round_robin/round_robin.cc

@@ -47,6 +47,7 @@
 #include "src/core/util/json/json.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/work_serializer.h"
 
 namespace grpc_core {
@@ -166,8 +167,6 @@ class RoundRobin final : public LoadBalancingPolicy {
   OrphanablePtr<RoundRobinEndpointList> latest_pending_endpoint_list_;
 
   bool shutdown_ = false;
-
-  absl::BitGen bit_gen_;
 };
 
 //
@@ -180,7 +179,7 @@ RoundRobin::Picker::Picker(
     : parent_(parent), pickers_(std::move(pickers)) {
   // For discussion on why we generate a random starting index for
   // the picker, see https://github.com/grpc/grpc-go/issues/2580.
-  size_t index = absl::Uniform<size_t>(parent->bit_gen_, 0, pickers_.size());
+  size_t index = absl::Uniform<size_t>(SharedBitGen(), 0, pickers_.size());
   last_picked_index_.store(index, std::memory_order_relaxed);
   GRPC_TRACE_LOG(round_robin, INFO)
       << "[RR " << parent_ << " picker " << this

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -68,6 +68,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
@@ -415,10 +416,9 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
 
   bool shutdown_ = false;
 
-  absl::BitGen bit_gen_;
-
   // Accessed by picker.
-  std::atomic<uint32_t> scheduler_state_{absl::Uniform<uint32_t>(bit_gen_)};
+  std::atomic<uint32_t> scheduler_state_{
+      absl::Uniform<uint32_t>(SharedBitGen())};
 };
 
 //
@@ -539,7 +539,7 @@ WeightedRoundRobin::Picker::Picker(RefCountedPtr<WeightedRoundRobin> wrr,
                                    WrrEndpointList* endpoint_list)
     : wrr_(std::move(wrr)),
       config_(wrr_->config_),
-      last_picked_index_(absl::Uniform<size_t>(wrr_->bit_gen_)) {
+      last_picked_index_(absl::Uniform<size_t>(SharedBitGen())) {
   for (auto& endpoint : endpoint_list->endpoints()) {
     auto* ep = static_cast<WrrEndpointList::WrrEndpoint*>(endpoint.get());
     if (ep->connectivity_state() == GRPC_CHANNEL_READY) {

data/src/core/load_balancing/weighted_target/weighted_target.cc

@@ -59,6 +59,7 @@
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
@@ -139,11 +140,6 @@ class WeightedTargetLb final : public LoadBalancingPolicy {
 
    private:
     PickerList pickers_;
-
-    // TODO(roth): Consider using a separate thread-local BitGen for each CPU
-    // to avoid the need for this mutex.
-    Mutex mu_;
-    absl::BitGen bit_gen_ ABSL_GUARDED_BY(&mu_);
   };
 
   // Each WeightedChild holds a ref to its parent WeightedTargetLb.
@@ -250,10 +246,8 @@ class WeightedTargetLb final : public LoadBalancingPolicy {
 WeightedTargetLb::PickResult WeightedTargetLb::WeightedPicker::Pick(
     PickArgs args) {
   // Generate a random number in [0, total weight).
-  const uint64_t key = [&]() {
-    MutexLock lock(&mu_);
-    return absl::Uniform<uint64_t>(bit_gen_, 0, pickers_.back().first);
-  }();
+  const uint64_t key =
+      absl::Uniform<uint64_t>(SharedBitGen(), 0, pickers_.back().first);
   // Find the index in pickers_ corresponding to key.
   size_t mid = 0;
   size_t start_index = 0;