grpc 1.72.0 → 1.73.0

data/src/core/client_channel/client_channel_filter.cc

@@ -501,7 +501,7 @@ class ClientChannelFilter::SubchannelWrapper final
       if (subchannel_node != nullptr) {
         auto it = chand_->subchannel_refcount_map_.find(subchannel_.get());
         if (it == chand_->subchannel_refcount_map_.end()) {
-          chand_->channelz_node_->AddChildSubchannel(subchannel_node->uuid());
+          subchannel_node->AddParent(chand_->channelz_node_);
           it = chand_->subchannel_refcount_map_.emplace(subchannel_.get(), 0)
                    .first;
         }
@@ -533,8 +533,7 @@ class ClientChannelFilter::SubchannelWrapper final
           CHECK(it != chand_->subchannel_refcount_map_.end());
           --it->second;
           if (it->second == 0) {
-            chand_->channelz_node_->RemoveChildSubchannel(
-                subchannel_node->uuid());
+            subchannel_node->RemoveParent(chand_->channelz_node_);
             chand_->subchannel_refcount_map_.erase(it);
           }
         }
@@ -617,20 +616,18 @@ class ClientChannelFilter::SubchannelWrapper final
       parent_.reset(DEBUG_LOCATION, "WatcherWrapper");
     }
 
-    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 {
       GRPC_TRACE_LOG(client_channel, INFO)
           << "chand=" << parent_->chand_
           << ": connectivity change for subchannel wrapper " << parent_.get()
           << " subchannel " << parent_->subchannel_.get()
           << "hopping into work_serializer";
-      self.release();  // Held by callback.
+      auto self = RefAsSubclass<WatcherWrapper>();
       parent_->chand_->work_serializer_->Run(
-          [this, state, status]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
-              *parent_->chand_->work_serializer_) {
-            ApplyUpdateInControlPlaneWorkSerializer(state, status);
-            Unref();
+          [self, state, status]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
+              *self->parent_->chand_->work_serializer_) {
+            self->ApplyUpdateInControlPlaneWorkSerializer(state, status);
           });
     }
 
@@ -1029,7 +1026,11 @@ RefCountedPtr<SubchannelPoolInterface> GetSubchannelPool(
   if (args.GetBool(GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL).value_or(false)) {
     return MakeRefCounted<LocalSubchannelPool>();
   }
-  return GlobalSubchannelPool::instance();
+  if (IsShardGlobalConnectionPoolEnabled()) {
+    return GlobalSubchannelPool::instance();
+  } else {
+    return LegacyGlobalSubchannelPool::instance();
+  }
 }
 
 }  // namespace
@@ -1551,11 +1552,13 @@ void ClientChannelFilter::UpdateStateLocked(grpc_connectivity_state state,
   state_tracker_.SetState(state, status, reason);
   if (channelz_node_ != nullptr) {
     channelz_node_->SetConnectivityState(state);
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string(
-            channelz::ChannelNode::GetChannelConnectivityStateChangeString(
-                state)));
+    std::string trace =
+        channelz::ChannelNode::GetChannelConnectivityStateChangeString(state);
+    if (!status.ok() || state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+      absl::StrAppend(&trace, " status:", status.ToString());
+    }
+    channelz_node_->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
+                                  grpc_slice_from_cpp_string(std::move(trace)));
   }
 }
 
@@ -2428,9 +2431,7 @@ void ClientChannelFilter::LoadBalancedCall::RecordCallCompletion(
 void ClientChannelFilter::LoadBalancedCall::RecordLatency() {
   // Compute latency and report it to the tracer.
   if (call_attempt_tracer() != nullptr) {
-    gpr_timespec latency =
-        gpr_cycle_counter_sub(gpr_get_cycle_counter(), lb_call_start_time_);
-    call_attempt_tracer()->RecordEnd(latency);
+    call_attempt_tracer()->RecordEnd();
   }
 }
 

data/src/core/client_channel/client_channel_filter.h

@@ -438,8 +438,6 @@ class ClientChannelFilter::LoadBalancedCall
 
   absl::AnyInvocable<void()> on_commit_;
 
-  gpr_cycle_counter lb_call_start_time_ = gpr_get_cycle_counter();
-
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
   const BackendMetricData* backend_metric_data_ = nullptr;
   std::unique_ptr<LoadBalancingPolicy::SubchannelCallTrackerInterface>

data/src/core/client_channel/connector.h

@@ -53,8 +53,6 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
     Transport* transport = nullptr;
     // Channel args to be passed to filters.
     ChannelArgs channel_args;
-    // Channelz socket node of the connected transport, if any.
-    RefCountedPtr<channelz::SocketNode> socket_node;
 
     void Reset() {
       if (transport != nullptr) {
@@ -62,7 +60,6 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
         transport = nullptr;
       }
       channel_args = ChannelArgs();
-      socket_node.reset();
     }
   };
 

data/src/core/client_channel/global_subchannel_pool.cc

@@ -26,12 +26,13 @@
 
 namespace grpc_core {
 
-RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
-  static GlobalSubchannelPool* p = new GlobalSubchannelPool();
-  return p->RefAsSubclass<GlobalSubchannelPool>();
+RefCountedPtr<LegacyGlobalSubchannelPool>
+LegacyGlobalSubchannelPool::instance() {
+  static LegacyGlobalSubchannelPool* p = new LegacyGlobalSubchannelPool();
+  return p->RefAsSubclass<LegacyGlobalSubchannelPool>();
 }
 
-RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
+RefCountedPtr<Subchannel> LegacyGlobalSubchannelPool::RegisterSubchannel(
     const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) {
   MutexLock lock(&mu_);
   auto it = subchannel_map_.find(key);
@@ -43,8 +44,8 @@ RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
   return constructed;
 }
 
-void GlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
-                                                Subchannel* subchannel) {
+void LegacyGlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
+                                                      Subchannel* subchannel) {
   MutexLock lock(&mu_);
   auto it = subchannel_map_.find(key);
   // delete only if key hasn't been re-registered to a different subchannel
@@ -54,7 +55,7 @@ void GlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
   }
 }
 
-RefCountedPtr<Subchannel> GlobalSubchannelPool::FindSubchannel(
+RefCountedPtr<Subchannel> LegacyGlobalSubchannelPool::FindSubchannel(
     const SubchannelKey& key) {
   MutexLock lock(&mu_);
   auto it = subchannel_map_.find(key);
@@ -62,4 +63,64 @@ RefCountedPtr<Subchannel> GlobalSubchannelPool::FindSubchannel(
   return it->second->RefIfNonZero();
 }
 
+RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
+  static GlobalSubchannelPool* p = new GlobalSubchannelPool();
+  return p->RefAsSubclass<GlobalSubchannelPool>();
+}
+
+RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
+    const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) {
+  auto shard_index = ShardIndex(key);
+  auto& write_shard = write_shards_[shard_index];
+  auto& read_shard = read_shards_[shard_index];
+  SubchannelMap old_map1;
+  SubchannelMap old_map2;
+  MutexLock lock(&write_shard.mu);
+  auto* existing = write_shard.map.Lookup(key);
+  if (existing != nullptr) return (*existing)->RefIfNonZero();
+  old_map1 = std::exchange(write_shard.map,
+                           write_shard.map.Add(key, constructed->WeakRef()));
+  MutexLock lock_read(&read_shard.mu);
+  old_map2 = std::exchange(read_shard.map, write_shard.map);
+  return constructed;
+}
+
+void GlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
+                                                Subchannel* subchannel) {
+  auto shard_index = ShardIndex(key);
+  auto& write_shard = write_shards_[shard_index];
+  auto& read_shard = read_shards_[shard_index];
+  SubchannelMap old_map1;
+  SubchannelMap old_map2;
+  MutexLock lock(&write_shard.mu);
+  auto* existing = write_shard.map.Lookup(key);
+  // delete only if key hasn't been re-registered to a different subchannel
+  // between strong-unreffing and unregistration of subchannel.
+  if (existing == nullptr || existing->get() != subchannel) return;
+  old_map1 = std::exchange(write_shard.map, write_shard.map.Remove(key));
+  MutexLock lock_read(&read_shard.mu);
+  old_map2 = std::exchange(read_shard.map, write_shard.map);
+}
+
+RefCountedPtr<Subchannel> GlobalSubchannelPool::FindSubchannel(
+    const SubchannelKey& key) {
+  auto shard_index = ShardIndex(key);
+  auto& read_shard = read_shards_[shard_index];
+  read_shard.mu.Lock();
+  auto map = read_shard.map;
+  read_shard.mu.Unlock();
+  auto* subchannel = map.Lookup(key);
+  if (subchannel == nullptr) return nullptr;
+  return (*subchannel)->RefIfNonZero();
+}
+
+size_t GlobalSubchannelPool::ShardIndex(const SubchannelKey& key) {
+  absl::string_view addr(key.address().addr, key.address().len);
+  return absl::HashOf(addr) % kShards;
+}
+
+GlobalSubchannelPool::GlobalSubchannelPool() = default;
+
+GlobalSubchannelPool::~GlobalSubchannelPool() = default;
+
 }  // namespace grpc_core

data/src/core/client_channel/global_subchannel_pool.h

@@ -32,10 +32,10 @@ namespace grpc_core {
 
 // The global subchannel pool. It shares subchannels among channels. There
 // should be only one instance of this class.
-class GlobalSubchannelPool final : public SubchannelPoolInterface {
+class LegacyGlobalSubchannelPool final : public SubchannelPoolInterface {
  public:
   // Gets the singleton instance.
-  static RefCountedPtr<GlobalSubchannelPool> instance();
+  static RefCountedPtr<LegacyGlobalSubchannelPool> instance();
 
   // Implements interface methods.
   RefCountedPtr<Subchannel> RegisterSubchannel(
@@ -48,8 +48,8 @@ class GlobalSubchannelPool final : public SubchannelPoolInterface {
       ABSL_LOCKS_EXCLUDED(mu_);
 
  private:
-  GlobalSubchannelPool() {}
-  ~GlobalSubchannelPool() override {}
+  LegacyGlobalSubchannelPool() {}
+  ~LegacyGlobalSubchannelPool() override {}
 
   // A map from subchannel key to subchannel.
   std::map<SubchannelKey, Subchannel*> subchannel_map_ ABSL_GUARDED_BY(mu_);
@@ -57,6 +57,39 @@ class GlobalSubchannelPool final : public SubchannelPoolInterface {
   Mutex mu_;
 };
 
+// The global subchannel pool. It shares subchannels among channels. There
+// should be only one instance of this class.
+class GlobalSubchannelPool final : public SubchannelPoolInterface {
+ public:
+  // Gets the singleton instance.
+  static RefCountedPtr<GlobalSubchannelPool> instance();
+
+  // Implements interface methods.
+  RefCountedPtr<Subchannel> RegisterSubchannel(
+      const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) override;
+  void UnregisterSubchannel(const SubchannelKey& key,
+                            Subchannel* subchannel) override;
+  RefCountedPtr<Subchannel> FindSubchannel(const SubchannelKey& key) override;
+
+ private:
+  GlobalSubchannelPool();
+  ~GlobalSubchannelPool() override;
+
+  static const size_t kShards = 127;
+
+  using SubchannelMap = AVL<SubchannelKey, WeakRefCountedPtr<Subchannel>>;
+  struct LockedMap {
+    Mutex mu;
+    SubchannelMap map ABSL_GUARDED_BY(mu);
+  };
+  using ShardedMap = std::array<LockedMap, kShards>;
+
+  static size_t ShardIndex(const SubchannelKey& key);
+
+  ShardedMap write_shards_;
+  ShardedMap read_shards_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_GLOBAL_SUBCHANNEL_POOL_H

data/src/core/client_channel/subchannel.cc

@@ -452,10 +452,8 @@ void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
 void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
     grpc_connectivity_state state, const absl::Status& status) {
   for (const auto& watcher : watchers_) {
-    subchannel_->work_serializer_.Run([watcher = watcher->Ref(), state,
-                                       status]() mutable {
-      auto* watcher_ptr = watcher.get();
-      watcher_ptr->OnConnectivityStateChange(std::move(watcher), state, status);
+    subchannel_->work_serializer_.Run([watcher, state, status]() {
+      watcher->OnConnectivityStateChange(state, status);
     });
   }
 }
@@ -551,6 +549,8 @@ Subchannel::Subchannel(SubchannelKey key,
     channelz_node_->AddTraceEvent(
         channelz::ChannelTrace::Severity::Info,
         grpc_slice_from_static_string("subchannel created"));
+    channelz_node_->SetChannelArgs(args_);
+    args_ = args_.SetObject<channelz::BaseNode>(channelz_node_);
   }
 }
 
@@ -612,10 +612,8 @@ void Subchannel::WatchConnectivityState(
     grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
   }
   work_serializer_.Run(
-      [watcher = watcher->Ref(), state = state_, status = status_]() mutable {
-        auto* watcher_ptr = watcher.get();
-        watcher_ptr->OnConnectivityStateChange(std::move(watcher), state,
-                                               status);
+      [watcher, state = state_, status = status_]() {
+        watcher->OnConnectivityStateChange(state, status);
       },
       DEBUG_LOCATION);
   watcher_list_.AddWatcherLocked(std::move(watcher));
@@ -792,7 +790,7 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
 }
 
 bool Subchannel::PublishTransportLocked() {
-  auto socket_node = std::move(connecting_result_.socket_node);
+  auto socket_node = connecting_result_.transport->GetSocketNode();
   if (connecting_result_.transport->filter_stack_transport() != nullptr) {
     // Construct channel stack.
     // Builder takes ownership of transport.

data/src/core/client_channel/subchannel.h

@@ -168,14 +168,8 @@ class Subchannel final : public DualRefCounted<Subchannel> {
     // Invoked whenever the subchannel's connectivity state changes.
     // There will be only one invocation of this method on a given watcher
     // instance at any given time.
-    // A ref to the watcher is passed in here so that the implementation
-    // can unref it in the appropriate synchronization context (e.g.,
-    // inside a WorkSerializer).
-    // TODO(roth): Figure out a cleaner way to guarantee that the ref is
-    // released in the right context.
-    virtual void OnConnectivityStateChange(
-        RefCountedPtr<ConnectivityStateWatcherInterface> self,
-        grpc_connectivity_state state, const absl::Status& status) = 0;
+    virtual void OnConnectivityStateChange(grpc_connectivity_state state,
+                                           const absl::Status& status) = 0;
 
     virtual grpc_pollset_set* interested_parties() = 0;
   };

data/src/core/client_channel/subchannel_pool_interface.cc

@@ -38,13 +38,12 @@ SubchannelKey::SubchannelKey(const grpc_resolved_address& address,
                              const ChannelArgs& args)
     : address_(address), args_(args) {}
 
-bool SubchannelKey::operator<(const SubchannelKey& other) const {
-  if (address_.len < other.address_.len) return true;
-  if (address_.len > other.address_.len) return false;
+int SubchannelKey::Compare(const SubchannelKey& other) const {
+  if (address_.len < other.address_.len) return -1;
+  if (address_.len > other.address_.len) return 1;
   int r = memcmp(address_.addr, other.address_.addr, address_.len);
-  if (r < 0) return true;
-  if (r > 0) return false;
-  return args_ < other.args();
+  if (r != 0) return r;
+  return QsortCompare(args_, other.args_);
 }
 
 std::string SubchannelKey::ToString() const {

data/src/core/client_channel/subchannel_pool_interface.h

@@ -45,7 +45,17 @@ class SubchannelKey final {
   SubchannelKey(SubchannelKey&& other) noexcept = default;
   SubchannelKey& operator=(SubchannelKey&& other) noexcept = default;
 
-  bool operator<(const SubchannelKey& other) const;
+  bool operator<(const SubchannelKey& other) const {
+    return Compare(other) < 0;
+  }
+  bool operator>(const SubchannelKey& other) const {
+    return Compare(other) > 0;
+  }
+  bool operator==(const SubchannelKey& other) const {
+    return Compare(other) == 0;
+  }
+
+  int Compare(const SubchannelKey& other) const;
 
   const grpc_resolved_address& address() const { return address_; }
   const ChannelArgs& args() const { return args_; }

data/src/core/config/config_vars.cc

@@ -76,6 +76,11 @@ ABSL_FLAG(absl::optional<bool>, grpc_cpp_experimental_disable_reflection, {},
           "EXPERIMENTAL. Only respected when there is a dependency on "
           ":grpc++_reflection. If true, no reflection server will be "
           "automatically added.");
+ABSL_FLAG(
+    absl::optional<int32_t>, grpc_channelz_max_orphaned_nodes, {},
+    "EXPERIMENTAL: If non-zero, extend the lifetime of channelz nodes past the "
+    "underlying object lifetime, up to this many nodes. The value may be "
+    "adjusted slightly to account for implementation limits.");
 
 namespace grpc_core {
 
@@ -84,6 +89,10 @@ ConfigVars::ConfigVars(const Overrides& overrides)
           LoadConfig(FLAGS_grpc_client_channel_backup_poll_interval_ms,
                      "GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS",
                      overrides.client_channel_backup_poll_interval_ms, 5000)),
+      channelz_max_orphaned_nodes_(
+          LoadConfig(FLAGS_grpc_channelz_max_orphaned_nodes,
+                     "GRPC_CHANNELZ_MAX_ORPHANED_NODES",
+                     overrides.channelz_max_orphaned_nodes, 0)),
       enable_fork_support_(LoadConfig(
           FLAGS_grpc_enable_fork_support, "GRPC_ENABLE_FORK_SUPPORT",
           overrides.enable_fork_support, GRPC_ENABLE_FORK_SUPPORT_DEFAULT)),
@@ -146,7 +155,8 @@ std::string ConfigVars::ToString() const {
       ", not_use_system_ssl_roots: ", NotUseSystemSslRoots() ? "true" : "false",
       ", ssl_cipher_suites: ", "\"", absl::CEscape(SslCipherSuites()), "\"",
       ", cpp_experimental_disable_reflection: ",
-      CppExperimentalDisableReflection() ? "true" : "false");
+      CppExperimentalDisableReflection() ? "true" : "false",
+      ", channelz_max_orphaned_nodes: ", ChannelzMaxOrphanedNodes());
 }
 
 }  // namespace grpc_core

data/src/core/config/config_vars.h

@@ -35,6 +35,7 @@ class GPR_DLL ConfigVars {
  public:
   struct Overrides {
     absl::optional<int32_t> client_channel_backup_poll_interval_ms;
+    absl::optional<int32_t> channelz_max_orphaned_nodes;
     absl::optional<bool> enable_fork_support;
     absl::optional<bool> abort_on_leaks;
     absl::optional<bool> not_use_system_ssl_roots;
@@ -104,12 +105,19 @@ class GPR_DLL ConfigVars {
   bool CppExperimentalDisableReflection() const {
     return cpp_experimental_disable_reflection_;
   }
+  // EXPERIMENTAL: If non-zero, extend the lifetime of channelz nodes past the
+  // underlying object lifetime, up to this many nodes. The value may be
+  // adjusted slightly to account for implementation limits.
+  int32_t ChannelzMaxOrphanedNodes() const {
+    return channelz_max_orphaned_nodes_;
+  }
 
  private:
   explicit ConfigVars(const Overrides& overrides);
   static const ConfigVars& Load();
   static std::atomic<ConfigVars*> config_vars_;
   int32_t client_channel_backup_poll_interval_ms_;
+  int32_t channelz_max_orphaned_nodes_;
   bool enable_fork_support_;
   bool abort_on_leaks_;
   bool not_use_system_ssl_roots_;

data/src/core/config/core_configuration.cc

@@ -25,8 +25,10 @@
 namespace grpc_core {
 
 std::atomic<CoreConfiguration*> CoreConfiguration::config_{nullptr};
-std::atomic<CoreConfiguration::RegisteredBuilder*> CoreConfiguration::builders_{
-    nullptr};
+std::atomic<CoreConfiguration::RegisteredBuilder*>
+    CoreConfiguration::builders_[static_cast<size_t>(BuilderScope::kCount)]{
+        nullptr, nullptr};
+std::atomic<bool> CoreConfiguration::has_config_ever_been_produced_{false};
 void (*CoreConfiguration::default_builder_)(CoreConfiguration::Builder*);
 
 CoreConfiguration::Builder::Builder() = default;
@@ -46,18 +48,31 @@ CoreConfiguration::CoreConfiguration(Builder* builder)
       lb_policy_registry_(builder->lb_policy_registry_.Build()),
       proxy_mapper_registry_(builder->proxy_mapper_registry_.Build()),
       certificate_provider_registry_(
-          builder->certificate_provider_registry_.Build()) {}
+          builder->certificate_provider_registry_.Build()),
+      endpoint_transport_registry_(
+          builder->endpoint_transport_registry_.Build()) {}
 
 void CoreConfiguration::RegisterBuilder(
-    absl::AnyInvocable<void(Builder*)> builder) {
+    BuilderScope scope, absl::AnyInvocable<void(Builder*)> builder,
+    SourceLocation whence) {
   CHECK(config_.load(std::memory_order_relaxed) == nullptr)
       << "CoreConfiguration was already instantiated before builder "
          "registration was completed";
+  if (scope == BuilderScope::kPersistent) {
+    CHECK(!has_config_ever_been_produced_.load(std::memory_order_relaxed))
+        << "Persistent builders cannot be registered after the first "
+           "CoreConfiguration has been produced";
+  }
+  CHECK_NE(scope, BuilderScope::kCount);
+  auto& head = builders_[static_cast<size_t>(scope)];
   RegisteredBuilder* n = new RegisteredBuilder();
+  VLOG(4) << "Registering " << scope << " builder from " << whence.file() << ":"
+          << whence.line();
   n->builder = std::move(builder);
-  n->next = builders_.load(std::memory_order_relaxed);
-  while (!builders_.compare_exchange_weak(n->next, n, std::memory_order_acq_rel,
-                                          std::memory_order_relaxed)) {
+  n->whence = whence;
+  n->next = head.load(std::memory_order_relaxed);
+  while (!head.compare_exchange_weak(n->next, n, std::memory_order_acq_rel,
+                                     std::memory_order_relaxed)) {
   }
   CHECK(config_.load(std::memory_order_relaxed) == nullptr)
       << "CoreConfiguration was already instantiated before builder "
@@ -65,6 +80,7 @@ void CoreConfiguration::RegisterBuilder(
 }
 
 const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
+  has_config_ever_been_produced_.store(true, std::memory_order_relaxed);
   // Construct builder, pass it up to code that knows about build configuration
   Builder builder;
   // The linked list of builders stores things in reverse registration order.
@@ -72,13 +88,21 @@ const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
   // actually need to run things in forward registration order, so we iterate
   // once over the linked list to build a vector of builders, and then iterate
   // over said vector in reverse to actually run the builders.
+  // Note that we also iterate scopes in reverse order here too, so that when
+  // we run the builders in the reverse generated order we'll actually run
+  // persistent builders before ephemeral ones.
   std::vector<RegisteredBuilder*> registered_builders;
-  for (RegisteredBuilder* b = builders_.load(std::memory_order_acquire);
-       b != nullptr; b = b->next) {
-    registered_builders.push_back(b);
+  for (auto scope : {BuilderScope::kEphemeral, BuilderScope::kPersistent}) {
+    for (RegisteredBuilder* b = builders_[static_cast<size_t>(scope)].load(
+             std::memory_order_acquire);
+         b != nullptr; b = b->next) {
+      registered_builders.push_back(b);
+    }
   }
   for (auto it = registered_builders.rbegin(); it != registered_builders.rend();
        ++it) {
+    VLOG(4) << "Running builder from " << (*it)->whence.file() << ":"
+            << (*it)->whence.line();
     (*it)->builder(&builder);
   }
   // Finally, call the built in configuration builder.
@@ -100,12 +124,27 @@ const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
 void CoreConfiguration::Reset() {
   delete config_.exchange(nullptr, std::memory_order_acquire);
   RegisteredBuilder* builder =
-      builders_.exchange(nullptr, std::memory_order_acquire);
+      builders_[static_cast<size_t>(BuilderScope::kEphemeral)].exchange(
+          nullptr, std::memory_order_acquire);
+  while (builder != nullptr) {
+    RegisteredBuilder* next = builder->next;
+    delete builder;
+    builder = next;
+  }
+}
+
+void CoreConfiguration::
+    ResetEverythingIncludingPersistentBuildersAbsolutelyNotRecommended() {
+  has_config_ever_been_produced_.store(false, std::memory_order_relaxed);
+  RegisteredBuilder* builder =
+      builders_[static_cast<size_t>(BuilderScope::kPersistent)].exchange(
+          nullptr, std::memory_order_acquire);
   while (builder != nullptr) {
     RegisteredBuilder* next = builder->next;
     delete builder;
     builder = next;
   }
+  Reset();
 }
 
 }  // namespace grpc_core