grpc 1.62.0 → 1.64.0

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

@@ -14,15 +14,11 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 #include <stdlib.h>
-#include <string.h>
 
 #include <algorithm>
 #include <atomic>
-#include <functional>
 #include <map>
 #include <memory>
 #include <set>
@@ -32,974 +28,158 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/impl/connectivity_state.h>
-#include <grpc/support/log.h>
-
-#include "src/core/load_balancing/backend_metric_data.h"
-#include "src/core/load_balancing/endpoint_list.h"
-#include "src/core/load_balancing/oob_backend_metric.h"
-#include "src/core/load_balancing/subchannel_list.h"
-#include "src/core/load_balancing/weighted_round_robin/static_stride_scheduler.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/debug/stats_data.h"
-#include "src/core/lib/debug/trace.h"
-#include "src/core/lib/experiments/experiments.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_args.h"
-#include "src/core/lib/json/json_object_loader.h"
-#include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/load_balancing/lb_policy.h"
-#include "src/core/load_balancing/lb_policy_factory.h"
-#include "src/core/load_balancing/subchannel_interface.h"
-#include "src/core/resolver/endpoint_addresses.h"
-#include "src/core/resolver/server_address.h"
-
-namespace grpc_core {
-
-TraceFlag grpc_lb_wrr_trace(false, "weighted_round_robin_lb");
-
-namespace {
-
-constexpr absl::string_view kWeightedRoundRobin = "weighted_round_robin";
-
-// Config for WRR policy.
-class WeightedRoundRobinConfig : public LoadBalancingPolicy::Config {
- public:
-  WeightedRoundRobinConfig() = default;
-
-  WeightedRoundRobinConfig(const WeightedRoundRobinConfig&) = delete;
-  WeightedRoundRobinConfig& operator=(const WeightedRoundRobinConfig&) = delete;
-
-  WeightedRoundRobinConfig(WeightedRoundRobinConfig&&) = delete;
-  WeightedRoundRobinConfig& operator=(WeightedRoundRobinConfig&&) = delete;
-
-  absl::string_view name() const override { return kWeightedRoundRobin; }
-
-  bool enable_oob_load_report() const { return enable_oob_load_report_; }
-  Duration oob_reporting_period() const { return oob_reporting_period_; }
-  Duration blackout_period() const { return blackout_period_; }
-  Duration weight_update_period() const { return weight_update_period_; }
-  Duration weight_expiration_period() const {
-    return weight_expiration_period_;
-  }
-  float error_utilization_penalty() const { return error_utilization_penalty_; }
-
-  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
-    static const auto* loader =
-        JsonObjectLoader<WeightedRoundRobinConfig>()
-            .OptionalField("enableOobLoadReport",
-                           &WeightedRoundRobinConfig::enable_oob_load_report_)
-            .OptionalField("oobReportingPeriod",
-                           &WeightedRoundRobinConfig::oob_reporting_period_)
-            .OptionalField("blackoutPeriod",
-                           &WeightedRoundRobinConfig::blackout_period_)
-            .OptionalField("weightUpdatePeriod",
-                           &WeightedRoundRobinConfig::weight_update_period_)
-            .OptionalField("weightExpirationPeriod",
-                           &WeightedRoundRobinConfig::weight_expiration_period_)
-            .OptionalField(
-                "errorUtilizationPenalty",
-                &WeightedRoundRobinConfig::error_utilization_penalty_)
-            .Finish();
-    return loader;
-  }
-
-  void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
-    // Impose lower bound of 100ms on weightUpdatePeriod.
-    weight_update_period_ =
-        std::max(weight_update_period_, Duration::Milliseconds(100));
-    if (error_utilization_penalty_ < 0) {
-      ValidationErrors::ScopedField field(errors, ".errorUtilizationPenalty");
-      errors->AddError("must be non-negative");
-    }
-  }
-
- private:
-  bool enable_oob_load_report_ = false;
-  Duration oob_reporting_period_ = Duration::Seconds(10);
-  Duration blackout_period_ = Duration::Seconds(10);
-  Duration weight_update_period_ = Duration::Seconds(1);
-  Duration weight_expiration_period_ = Duration::Minutes(3);
-  float error_utilization_penalty_ = 1.0;
-};
-
-// Legacy WRR LB policy (not delegating to pick_first)
-class OldWeightedRoundRobin : public LoadBalancingPolicy {
- public:
-  explicit OldWeightedRoundRobin(Args args);
-
-  absl::string_view name() const override { return kWeightedRoundRobin; }
-
-  absl::Status UpdateLocked(UpdateArgs args) override;
-  void ResetBackoffLocked() override;
-
- private:
-  // Represents the weight for a given address.
-  class AddressWeight : public RefCounted<AddressWeight> {
-   public:
-    AddressWeight(RefCountedPtr<OldWeightedRoundRobin> wrr, std::string key)
-        : wrr_(std::move(wrr)), key_(std::move(key)) {}
-    ~AddressWeight() override;
-
-    void MaybeUpdateWeight(double qps, double eps, double utilization,
-                           float error_utilization_penalty);
-
-    float GetWeight(Timestamp now, Duration weight_expiration_period,
-                    Duration blackout_period);
-
-    void ResetNonEmptySince();
-
-   private:
-    RefCountedPtr<OldWeightedRoundRobin> wrr_;
-    const std::string key_;
-
-    Mutex mu_;
-    float weight_ ABSL_GUARDED_BY(&mu_) = 0;
-    Timestamp non_empty_since_ ABSL_GUARDED_BY(&mu_) = Timestamp::InfFuture();
-    Timestamp last_update_time_ ABSL_GUARDED_BY(&mu_) = Timestamp::InfPast();
-  };
-
-  // Forward declaration.
-  class WeightedRoundRobinSubchannelList;
-
-  // Data for a particular subchannel in a subchannel list.
-  // This subclass adds the following functionality:
-  // - Tracks the previous connectivity state of the subchannel, so that
-  //   we know how many subchannels are in each state.
-  class WeightedRoundRobinSubchannelData
-      : public SubchannelData<WeightedRoundRobinSubchannelList,
-                              WeightedRoundRobinSubchannelData> {
-   public:
-    WeightedRoundRobinSubchannelData(
-        SubchannelList<WeightedRoundRobinSubchannelList,
-                       WeightedRoundRobinSubchannelData>* subchannel_list,
-        const ServerAddress& address, RefCountedPtr<SubchannelInterface> sc);
-
-    absl::optional<grpc_connectivity_state> connectivity_state() const {
-      return logical_connectivity_state_;
-    }
-
-    RefCountedPtr<AddressWeight> weight() const { return weight_; }
-
-   private:
-    class OobWatcher : public OobBackendMetricWatcher {
-     public:
-      OobWatcher(RefCountedPtr<AddressWeight> weight,
-                 float error_utilization_penalty)
-          : weight_(std::move(weight)),
-            error_utilization_penalty_(error_utilization_penalty) {}
-
-      void OnBackendMetricReport(
-          const BackendMetricData& backend_metric_data) override;
-
-     private:
-      RefCountedPtr<AddressWeight> weight_;
-      const float error_utilization_penalty_;
-    };
-
-    // Performs connectivity state updates that need to be done only
-    // after we have started watching.
-    void ProcessConnectivityChangeLocked(
-        absl::optional<grpc_connectivity_state> old_state,
-        grpc_connectivity_state new_state) override;
-
-    // Updates the logical connectivity state.
-    void UpdateLogicalConnectivityStateLocked(
-        grpc_connectivity_state connectivity_state);
-
-    // The logical connectivity state of the subchannel.
-    // Note that the logical connectivity state may differ from the
-    // actual reported state in some cases (e.g., after we see
-    // TRANSIENT_FAILURE, we ignore any subsequent state changes until
-    // we see READY).
-    absl::optional<grpc_connectivity_state> logical_connectivity_state_;
-
-    RefCountedPtr<AddressWeight> weight_;
-  };
-
-  // A list of subchannels.
-  class WeightedRoundRobinSubchannelList
-      : public SubchannelList<WeightedRoundRobinSubchannelList,
-                              WeightedRoundRobinSubchannelData> {
-   public:
-    WeightedRoundRobinSubchannelList(OldWeightedRoundRobin* policy,
-                                     EndpointAddressesIterator* addresses,
-                                     const ChannelArgs& args)
-        : SubchannelList(policy,
-                         (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)
-                              ? "WeightedRoundRobinSubchannelList"
-                              : nullptr),
-                         addresses, policy->channel_control_helper(), args) {
-      // Need to maintain a ref to the LB policy as long as we maintain
-      // any references to subchannels, since the subchannels'
-      // pollset_sets will include the LB policy's pollset_set.
-      policy->Ref(DEBUG_LOCATION, "subchannel_list").release();
-    }
-
-    ~WeightedRoundRobinSubchannelList() override {
-      OldWeightedRoundRobin* p = static_cast<OldWeightedRoundRobin*>(policy());
-      p->Unref(DEBUG_LOCATION, "subchannel_list");
-    }
-
-    // Updates the counters of subchannels in each state when a
-    // subchannel transitions from old_state to new_state.
-    void UpdateStateCountersLocked(
-        absl::optional<grpc_connectivity_state> old_state,
-        grpc_connectivity_state new_state);
-
-    // Ensures that the right subchannel list is used and then updates
-    // the aggregated connectivity state based on the subchannel list's
-    // state counters.
-    void MaybeUpdateAggregatedConnectivityStateLocked(
-        absl::Status status_for_tf);
-
-   private:
-    std::shared_ptr<WorkSerializer> work_serializer() const override {
-      return static_cast<OldWeightedRoundRobin*>(policy())->work_serializer();
-    }
-
-    std::string CountersString() const {
-      return absl::StrCat("num_subchannels=", num_subchannels(),
-                          " num_ready=", num_ready_,
-                          " num_connecting=", num_connecting_,
-                          " num_transient_failure=", num_transient_failure_);
-    }
-
-    size_t num_ready_ = 0;
-    size_t num_connecting_ = 0;
-    size_t num_transient_failure_ = 0;
-
-    absl::Status last_failure_;
-  };
-
-  // A picker that performs WRR picks with weights based on
-  // endpoint-reported utilization and QPS.
-  class Picker : public SubchannelPicker {
-   public:
-    Picker(RefCountedPtr<OldWeightedRoundRobin> wrr,
-           WeightedRoundRobinSubchannelList* subchannel_list);
-
-    ~Picker() override;
-
-    PickResult Pick(PickArgs args) override;
-
-    void Orphan() override;
-
-   private:
-    // A call tracker that collects per-call endpoint utilization reports.
-    class SubchannelCallTracker : public SubchannelCallTrackerInterface {
-     public:
-      SubchannelCallTracker(RefCountedPtr<AddressWeight> weight,
-                            float error_utilization_penalty)
-          : weight_(std::move(weight)),
-            error_utilization_penalty_(error_utilization_penalty) {}
-
-      void Start() override {}
-
-      void Finish(FinishArgs args) override;
-
-     private:
-      RefCountedPtr<AddressWeight> weight_;
-      const float error_utilization_penalty_;
-    };
-
-    // Info stored about each subchannel.
-    struct SubchannelInfo {
-      SubchannelInfo(RefCountedPtr<SubchannelInterface> subchannel,
-                     RefCountedPtr<AddressWeight> weight)
-          : subchannel(std::move(subchannel)), weight(std::move(weight)) {}
-
-      RefCountedPtr<SubchannelInterface> subchannel;
-      RefCountedPtr<AddressWeight> weight;
-    };
-
-    // Returns the index into subchannels_ to be picked.
-    size_t PickIndex();
-
-    // Builds a new scheduler and swaps it into place, then starts a
-    // timer for the next update.
-    void BuildSchedulerAndStartTimerLocked()
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&timer_mu_);
-
-    RefCountedPtr<OldWeightedRoundRobin> wrr_;
-    RefCountedPtr<WeightedRoundRobinConfig> config_;
-    std::vector<SubchannelInfo> subchannels_;
-
-    Mutex scheduler_mu_;
-    std::shared_ptr<StaticStrideScheduler> scheduler_
-        ABSL_GUARDED_BY(&scheduler_mu_);
-
-    Mutex timer_mu_ ABSL_ACQUIRED_BEFORE(&scheduler_mu_);
-    absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
-        timer_handle_ ABSL_GUARDED_BY(&timer_mu_);
-
-    // Used when falling back to RR.
-    std::atomic<size_t> last_picked_index_;
-  };
-
-  ~OldWeightedRoundRobin() override;
-
-  void ShutdownLocked() override;
-
-  RefCountedPtr<AddressWeight> GetOrCreateWeight(
-      const grpc_resolved_address& address);
-
-  RefCountedPtr<WeightedRoundRobinConfig> config_;
-
-  // List of subchannels.
-  RefCountedPtr<WeightedRoundRobinSubchannelList> subchannel_list_;
-  // Latest pending subchannel list.
-  // When we get an updated address list, we create a new subchannel list
-  // for it here, and we wait to swap it into subchannel_list_ until the new
-  // list becomes READY.
-  RefCountedPtr<WeightedRoundRobinSubchannelList>
-      latest_pending_subchannel_list_;
-
-  Mutex address_weight_map_mu_;
-  std::map<std::string, AddressWeight*, std::less<>> address_weight_map_
-      ABSL_GUARDED_BY(&address_weight_map_mu_);
-
-  bool shutdown_ = false;
-
-  absl::BitGen bit_gen_;
-
-  // Accessed by picker.
-  std::atomic<uint32_t> scheduler_state_{absl::Uniform<uint32_t>(bit_gen_)};
-};
-
-//
-// OldWeightedRoundRobin::AddressWeight
-//
-
-OldWeightedRoundRobin::AddressWeight::~AddressWeight() {
-  MutexLock lock(&wrr_->address_weight_map_mu_);
-  auto it = wrr_->address_weight_map_.find(key_);
-  if (it != wrr_->address_weight_map_.end() && it->second == this) {
-    wrr_->address_weight_map_.erase(it);
-  }
-}
-
-void OldWeightedRoundRobin::AddressWeight::MaybeUpdateWeight(
-    double qps, double eps, double utilization,
-    float error_utilization_penalty) {
-  // Compute weight.
-  float weight = 0;
-  if (qps > 0 && utilization > 0) {
-    double penalty = 0.0;
-    if (eps > 0 && error_utilization_penalty > 0) {
-      penalty = eps / qps * error_utilization_penalty;
-    }
-    weight = qps / (utilization + penalty);
-  }
-  if (weight == 0) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO,
-              "[WRR %p] subchannel %s: qps=%f, eps=%f, utilization=%f: "
-              "error_util_penalty=%f, weight=%f (not updating)",
-              wrr_.get(), key_.c_str(), qps, eps, utilization,
-              error_utilization_penalty, weight);
-    }
-    return;
-  }
-  Timestamp now = Timestamp::Now();
-  // Grab the lock and update the data.
-  MutexLock lock(&mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p] subchannel %s: qps=%f, eps=%f, utilization=%f "
-            "error_util_penalty=%f : setting weight=%f weight_=%f now=%s "
-            "last_update_time_=%s non_empty_since_=%s",
-            wrr_.get(), key_.c_str(), qps, eps, utilization,
-            error_utilization_penalty, weight, weight_, now.ToString().c_str(),
-            last_update_time_.ToString().c_str(),
-            non_empty_since_.ToString().c_str());
-  }
-  if (non_empty_since_ == Timestamp::InfFuture()) non_empty_since_ = now;
-  weight_ = weight;
-  last_update_time_ = now;
-}
-
-float OldWeightedRoundRobin::AddressWeight::GetWeight(
-    Timestamp now, Duration weight_expiration_period,
-    Duration blackout_period) {
-  MutexLock lock(&mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p] subchannel %s: getting weight: now=%s "
-            "weight_expiration_period=%s blackout_period=%s "
-            "last_update_time_=%s non_empty_since_=%s weight_=%f",
-            wrr_.get(), key_.c_str(), now.ToString().c_str(),
-            weight_expiration_period.ToString().c_str(),
-            blackout_period.ToString().c_str(),
-            last_update_time_.ToString().c_str(),
-            non_empty_since_.ToString().c_str(), weight_);
-  }
-  // If the most recent update was longer ago than the expiration
-  // period, reset non_empty_since_ so that we apply the blackout period
-  // again if we start getting data again in the future, and return 0.
-  if (now - last_update_time_ >= weight_expiration_period) {
-    non_empty_since_ = Timestamp::InfFuture();
-    return 0;
-  }
-  // If we don't have at least blackout_period worth of data, return 0.
-  if (blackout_period > Duration::Zero() &&
-      now - non_empty_since_ < blackout_period) {
-    return 0;
-  }
-  // Otherwise, return the weight.
-  return weight_;
-}
-
-void OldWeightedRoundRobin::AddressWeight::ResetNonEmptySince() {
-  MutexLock lock(&mu_);
-  non_empty_since_ = Timestamp::InfFuture();
-}
-
-//
-// OldWeightedRoundRobin::Picker::SubchannelCallTracker
-//
-
-void OldWeightedRoundRobin::Picker::SubchannelCallTracker::Finish(
-    FinishArgs args) {
-  auto* backend_metric_data =
-      args.backend_metric_accessor->GetBackendMetricData();
-  double qps = 0;
-  double eps = 0;
-  double utilization = 0;
-  if (backend_metric_data != nullptr) {
-    qps = backend_metric_data->qps;
-    eps = backend_metric_data->eps;
-    utilization = backend_metric_data->application_utilization;
-    if (utilization <= 0) {
-      utilization = backend_metric_data->cpu_utilization;
-    }
-  }
-  weight_->MaybeUpdateWeight(qps, eps, utilization, error_utilization_penalty_);
-}
-
-//
-// OldWeightedRoundRobin::Picker
-//
-
-OldWeightedRoundRobin::Picker::Picker(
-    RefCountedPtr<OldWeightedRoundRobin> wrr,
-    WeightedRoundRobinSubchannelList* subchannel_list)
-    : wrr_(std::move(wrr)),
-      config_(wrr_->config_),
-      last_picked_index_(absl::Uniform<size_t>(wrr_->bit_gen_)) {
-  for (size_t i = 0; i < subchannel_list->num_subchannels(); ++i) {
-    WeightedRoundRobinSubchannelData* sd = subchannel_list->subchannel(i);
-    if (sd->connectivity_state() == GRPC_CHANNEL_READY) {
-      subchannels_.emplace_back(sd->subchannel()->Ref(), sd->weight());
-    }
-  }
-  global_stats().IncrementWrrSubchannelListSize(
-      subchannel_list->num_subchannels());
-  global_stats().IncrementWrrSubchannelReadySize(subchannels_.size());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p picker %p] created picker from subchannel_list=%p "
-            "with %" PRIuPTR " subchannels",
-            wrr_.get(), this, subchannel_list, subchannels_.size());
-  }
-  BuildSchedulerAndStartTimerLocked();
-}
-
-OldWeightedRoundRobin::Picker::~Picker() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] destroying picker", wrr_.get(), this);
-  }
-}
-
-void OldWeightedRoundRobin::Picker::Orphan() {
-  MutexLock lock(&timer_mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] cancelling timer", wrr_.get(), this);
-  }
-  wrr_->channel_control_helper()->GetEventEngine()->Cancel(*timer_handle_);
-  timer_handle_.reset();
-}
-
-OldWeightedRoundRobin::PickResult OldWeightedRoundRobin::Picker::Pick(
-    PickArgs /*args*/) {
-  size_t index = PickIndex();
-  GPR_ASSERT(index < subchannels_.size());
-  auto& subchannel_info = subchannels_[index];
-  // Collect per-call utilization data if needed.
-  std::unique_ptr<SubchannelCallTrackerInterface> subchannel_call_tracker;
-  if (!config_->enable_oob_load_report()) {
-    subchannel_call_tracker = std::make_unique<SubchannelCallTracker>(
-        subchannel_info.weight, config_->error_utilization_penalty());
-  }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p picker %p] returning index %" PRIuPTR ", subchannel=%p",
-            wrr_.get(), this, index, subchannel_info.subchannel.get());
-  }
-  return PickResult::Complete(subchannel_info.subchannel,
-                              std::move(subchannel_call_tracker));
-}
-
-size_t OldWeightedRoundRobin::Picker::PickIndex() {
-  // Grab a ref to the scheduler.
-  std::shared_ptr<StaticStrideScheduler> scheduler;
-  {
-    MutexLock lock(&scheduler_mu_);
-    scheduler = scheduler_;
-  }
-  // If we have a scheduler, use it to do a WRR pick.
-  if (scheduler != nullptr) return scheduler->Pick();
-  // We don't have a scheduler (i.e., either all of the weights are 0 or
-  // there is only one subchannel), so fall back to RR.
-  return last_picked_index_.fetch_add(1) % subchannels_.size();
-}
-
-void OldWeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
-  // Build scheduler.
-  const Timestamp now = Timestamp::Now();
-  std::vector<float> weights;
-  weights.reserve(subchannels_.size());
-  for (const auto& subchannel : subchannels_) {
-    weights.push_back(subchannel.weight->GetWeight(
-        now, config_->weight_expiration_period(), config_->blackout_period()));
-  }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] new weights: %s", wrr_.get(), this,
-            absl::StrJoin(weights, " ").c_str());
-  }
-  auto scheduler_or = StaticStrideScheduler::Make(
-      weights, [this]() { return wrr_->scheduler_state_.fetch_add(1); });
-  std::shared_ptr<StaticStrideScheduler> scheduler;
-  if (scheduler_or.has_value()) {
-    scheduler =
-        std::make_shared<StaticStrideScheduler>(std::move(*scheduler_or));
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO, "[WRR %p picker %p] new scheduler: %p", wrr_.get(),
-              this, scheduler.get());
-    }
-  } else if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] no scheduler, falling back to RR",
-            wrr_.get(), this);
-  }
-  {
-    MutexLock lock(&scheduler_mu_);
-    scheduler_ = std::move(scheduler);
-  }
-  // Start timer.
-  timer_handle_ = wrr_->channel_control_helper()->GetEventEngine()->RunAfter(
-      config_->weight_update_period(),
-      [self = WeakRefAsSubclass<Picker>(),
-       work_serializer = wrr_->work_serializer()]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
-        ExecCtx exec_ctx;
-        {
-          MutexLock lock(&self->timer_mu_);
-          if (self->timer_handle_.has_value()) {
-            if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-              gpr_log(GPR_INFO, "[WRR %p picker %p] timer fired",
-                      self->wrr_.get(), self.get());
-            }
-            self->BuildSchedulerAndStartTimerLocked();
-          }
-        }
-        if (!IsWorkSerializerDispatchEnabled()) {
-          // Release the picker ref inside the WorkSerializer.
-          work_serializer->Run([self = std::move(self)]() {}, DEBUG_LOCATION);
-          return;
-        }
-        self.reset();
-      });
-}
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
 
-//
-// WeightedRoundRobin
-//
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/connectivity_state.h>
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-OldWeightedRoundRobin::OldWeightedRoundRobin(Args args)
-    : LoadBalancingPolicy(std::move(args)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p] Created", this);
-  }
-}
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/metrics.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/gprpp/work_serializer.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
+#include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/load_balancing/backend_metric_data.h"
+#include "src/core/load_balancing/endpoint_list.h"
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/load_balancing/lb_policy_factory.h"
+#include "src/core/load_balancing/oob_backend_metric.h"
+#include "src/core/load_balancing/subchannel_interface.h"
+#include "src/core/load_balancing/weighted_round_robin/static_stride_scheduler.h"
+#include "src/core/load_balancing/weighted_target/weighted_target.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
-OldWeightedRoundRobin::~OldWeightedRoundRobin() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p] Destroying Round Robin policy", this);
-  }
-  GPR_ASSERT(subchannel_list_ == nullptr);
-  GPR_ASSERT(latest_pending_subchannel_list_ == nullptr);
-}
+namespace grpc_core {
 
-void OldWeightedRoundRobin::ShutdownLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p] Shutting down", this);
-  }
-  shutdown_ = true;
-  subchannel_list_.reset();
-  latest_pending_subchannel_list_.reset();
-}
+TraceFlag grpc_lb_wrr_trace(false, "weighted_round_robin_lb");
 
-void OldWeightedRoundRobin::ResetBackoffLocked() {
-  subchannel_list_->ResetBackoffLocked();
-  if (latest_pending_subchannel_list_ != nullptr) {
-    latest_pending_subchannel_list_->ResetBackoffLocked();
-  }
-}
+namespace {
 
-absl::Status OldWeightedRoundRobin::UpdateLocked(UpdateArgs args) {
-  global_stats().IncrementWrrUpdates();
-  config_ = args.config.TakeAsSubclass<WeightedRoundRobinConfig>();
-  std::shared_ptr<EndpointAddressesIterator> addresses;
-  if (args.addresses.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO, "[WRR %p] received update", this);
-    }
-    // Weed out duplicate addresses.  Also sort the addresses so that if
-    // the set of the addresses don't change, their indexes in the
-    // subchannel list don't change, since this avoids unnecessary churn
-    // in the picker.  Note that this does not ensure that if a given
-    // address remains present that it will have the same index; if,
-    // for example, an address at the end of the list is replaced with one
-    // that sorts much earlier in the list, then all of the addresses in
-    // between those two positions will have changed indexes.
-    struct AddressLessThan {
-      bool operator()(const ServerAddress& address1,
-                      const ServerAddress& address2) const {
-        const grpc_resolved_address& addr1 = address1.address();
-        const grpc_resolved_address& addr2 = address2.address();
-        if (addr1.len != addr2.len) return addr1.len < addr2.len;
-        return memcmp(addr1.addr, addr2.addr, addr1.len) < 0;
-      }
-    };
-    std::set<ServerAddress, AddressLessThan> ordered_addresses;
-    (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
-      ordered_addresses.insert(endpoint);
-    });
-    addresses = std::make_shared<EndpointAddressesListIterator>(
-        ServerAddressList(ordered_addresses.begin(), ordered_addresses.end()));
-  } else {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO, "[WRR %p] received update with address error: %s", this,
-              args.addresses.status().ToString().c_str());
-    }
-    // If we already have a subchannel list, then keep using the existing
-    // list, but still report back that the update was not accepted.
-    if (subchannel_list_ != nullptr) return args.addresses.status();
-  }
-  // Create new subchannel list, replacing the previous pending list, if any.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace) &&
-      latest_pending_subchannel_list_ != nullptr) {
-    gpr_log(GPR_INFO, "[WRR %p] replacing previous pending subchannel list %p",
-            this, latest_pending_subchannel_list_.get());
-  }
-  latest_pending_subchannel_list_ =
-      MakeRefCounted<WeightedRoundRobinSubchannelList>(this, addresses.get(),
-                                                       args.args);
-  latest_pending_subchannel_list_->StartWatchingLocked(args.args);
-  // If the new list is empty, immediately promote it to
-  // subchannel_list_ and report TRANSIENT_FAILURE.
-  if (latest_pending_subchannel_list_->num_subchannels() == 0) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace) &&
-        subchannel_list_ != nullptr) {
-      gpr_log(GPR_INFO, "[WRR %p] replacing previous subchannel list %p", this,
-              subchannel_list_.get());
-    }
-    subchannel_list_ = std::move(latest_pending_subchannel_list_);
-    absl::Status status =
-        args.addresses.ok() ? absl::UnavailableError(absl::StrCat(
-                                  "empty address list: ", args.resolution_note))
-                            : args.addresses.status();
-    channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-        MakeRefCounted<TransientFailurePicker>(status));
-    return status;
-  }
-  // Otherwise, if this is the initial update, immediately promote it to
-  // subchannel_list_.
-  if (subchannel_list_.get() == nullptr) {
-    subchannel_list_ = std::move(latest_pending_subchannel_list_);
-  }
-  return absl::OkStatus();
-}
+constexpr absl::string_view kWeightedRoundRobin = "weighted_round_robin";
 
-RefCountedPtr<OldWeightedRoundRobin::AddressWeight>
-OldWeightedRoundRobin::GetOrCreateWeight(const grpc_resolved_address& address) {
-  auto key = grpc_sockaddr_to_uri(&address);
-  if (!key.ok()) return nullptr;
-  MutexLock lock(&address_weight_map_mu_);
-  auto it = address_weight_map_.find(*key);
-  if (it != address_weight_map_.end()) {
-    auto weight = it->second->RefIfNonZero();
-    if (weight != nullptr) return weight;
-  }
-  auto weight = MakeRefCounted<AddressWeight>(
-      RefAsSubclass<OldWeightedRoundRobin>(DEBUG_LOCATION, "AddressWeight"),
-      *key);
-  address_weight_map_.emplace(*key, weight.get());
-  return weight;
-}
+constexpr absl::string_view kMetricLabelLocality = "grpc.lb.locality";
+
+const auto kMetricRrFallback = GlobalInstrumentsRegistry::RegisterUInt64Counter(
+    "grpc.lb.wrr.rr_fallback",
+    "EXPERIMENTAL.  Number of scheduler updates in which there were not "
+    "enough endpoints with valid weight, which caused the WRR policy to "
+    "fall back to RR behavior.",
+    "{update}", {kMetricLabelTarget}, {kMetricLabelLocality}, false);
+
+const auto kMetricEndpointWeightNotYetUsable =
+    GlobalInstrumentsRegistry::RegisterUInt64Counter(
+        "grpc.lb.wrr.endpoint_weight_not_yet_usable",
+        "EXPERIMENTAL.  Number of endpoints from each scheduler update that "
+        "don't yet have usable weight information (i.e., either the load "
+        "report has not yet been received, or it is within the blackout "
+        "period).",
+        "{endpoint}", {kMetricLabelTarget}, {kMetricLabelLocality}, false);
+
+const auto kMetricEndpointWeightStale =
+    GlobalInstrumentsRegistry::RegisterUInt64Counter(
+        "grpc.lb.wrr.endpoint_weight_stale",
+        "EXPERIMENTAL.  Number of endpoints from each scheduler update whose "
+        "latest weight is older than the expiration period.",
+        "{endpoint}", {kMetricLabelTarget}, {kMetricLabelLocality}, false);
+
+const auto kMetricEndpointWeights =
+    GlobalInstrumentsRegistry::RegisterDoubleHistogram(
+        "grpc.lb.wrr.endpoint_weights",
+        "EXPERIMENTAL.  The histogram buckets will be endpoint weight ranges.  "
+        "Each bucket will be a counter that is incremented once for every "
+        "endpoint whose weight is within that range. Note that endpoints "
+        "without usable weights will have weight 0.",
+        "{weight}", {kMetricLabelTarget}, {kMetricLabelLocality}, false);
 
-//
-// OldWeightedRoundRobin::WeightedRoundRobinSubchannelList
-//
+// Config for WRR policy.
+class WeightedRoundRobinConfig final : public LoadBalancingPolicy::Config {
+ public:
+  WeightedRoundRobinConfig() = default;
 
-void OldWeightedRoundRobin::WeightedRoundRobinSubchannelList::
-    UpdateStateCountersLocked(absl::optional<grpc_connectivity_state> old_state,
-                              grpc_connectivity_state new_state) {
-  if (old_state.has_value()) {
-    GPR_ASSERT(*old_state != GRPC_CHANNEL_SHUTDOWN);
-    if (*old_state == GRPC_CHANNEL_READY) {
-      GPR_ASSERT(num_ready_ > 0);
-      --num_ready_;
-    } else if (*old_state == GRPC_CHANNEL_CONNECTING) {
-      GPR_ASSERT(num_connecting_ > 0);
-      --num_connecting_;
-    } else if (*old_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-      GPR_ASSERT(num_transient_failure_ > 0);
-      --num_transient_failure_;
-    }
-  }
-  GPR_ASSERT(new_state != GRPC_CHANNEL_SHUTDOWN);
-  if (new_state == GRPC_CHANNEL_READY) {
-    ++num_ready_;
-  } else if (new_state == GRPC_CHANNEL_CONNECTING) {
-    ++num_connecting_;
-  } else if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-    ++num_transient_failure_;
-  }
-}
+  WeightedRoundRobinConfig(const WeightedRoundRobinConfig&) = delete;
+  WeightedRoundRobinConfig& operator=(const WeightedRoundRobinConfig&) = delete;
 
-void OldWeightedRoundRobin::WeightedRoundRobinSubchannelList::
-    MaybeUpdateAggregatedConnectivityStateLocked(absl::Status status_for_tf) {
-  OldWeightedRoundRobin* p = static_cast<OldWeightedRoundRobin*>(policy());
-  // If this is latest_pending_subchannel_list_, then swap it into
-  // subchannel_list_ in the following cases:
-  // - subchannel_list_ has no READY subchannels.
-  // - This list has at least one READY subchannel and we have seen the
-  //   initial connectivity state notification for all subchannels.
-  // - All of the subchannels in this list are in TRANSIENT_FAILURE.
-  //   (This may cause the channel to go from READY to TRANSIENT_FAILURE,
-  //   but we're doing what the control plane told us to do.)
-  if (p->latest_pending_subchannel_list_.get() == this &&
-      (p->subchannel_list_->num_ready_ == 0 ||
-       (num_ready_ > 0 && AllSubchannelsSeenInitialState()) ||
-       num_transient_failure_ == num_subchannels())) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      const std::string old_counters_string =
-          p->subchannel_list_ != nullptr ? p->subchannel_list_->CountersString()
-                                         : "";
-      gpr_log(
-          GPR_INFO,
-          "[WRR %p] swapping out subchannel list %p (%s) in favor of %p (%s)",
-          p, p->subchannel_list_.get(), old_counters_string.c_str(), this,
-          CountersString().c_str());
-    }
-    p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
-  }
-  // Only set connectivity state if this is the current subchannel list.
-  if (p->subchannel_list_.get() != this) return;
-  // First matching rule wins:
-  // 1) ANY subchannel is READY => policy is READY.
-  // 2) ANY subchannel is CONNECTING => policy is CONNECTING.
-  // 3) ALL subchannels are TRANSIENT_FAILURE => policy is TRANSIENT_FAILURE.
-  if (num_ready_ > 0) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO, "[WRR %p] reporting READY with subchannel list %p", p,
-              this);
-    }
-    p->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_READY, absl::Status(),
-        MakeRefCounted<Picker>(p->RefAsSubclass<OldWeightedRoundRobin>(),
-                               this));
-  } else if (num_connecting_ > 0) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO, "[WRR %p] reporting CONNECTING with subchannel list %p",
-              p, this);
-    }
-    p->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_CONNECTING, absl::Status(),
-        MakeRefCounted<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
-  } else if (num_transient_failure_ == num_subchannels()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(
-          GPR_INFO,
-          "[WRR %p] reporting TRANSIENT_FAILURE with subchannel list %p: %s", p,
-          this, status_for_tf.ToString().c_str());
-    }
-    if (!status_for_tf.ok()) {
-      last_failure_ = absl::UnavailableError(
-          absl::StrCat("connections to all backends failing; last error: ",
-                       status_for_tf.ToString()));
-    }
-    p->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE, last_failure_,
-        MakeRefCounted<TransientFailurePicker>(last_failure_));
-  }
-}
+  WeightedRoundRobinConfig(WeightedRoundRobinConfig&&) = delete;
+  WeightedRoundRobinConfig& operator=(WeightedRoundRobinConfig&&) = delete;
 
-//
-// OldWeightedRoundRobin::WeightedRoundRobinSubchannelData::OobWatcher
-//
+  absl::string_view name() const override { return kWeightedRoundRobin; }
 
-void OldWeightedRoundRobin::WeightedRoundRobinSubchannelData::OobWatcher::
-    OnBackendMetricReport(const BackendMetricData& backend_metric_data) {
-  double utilization = backend_metric_data.application_utilization;
-  if (utilization <= 0) {
-    utilization = backend_metric_data.cpu_utilization;
+  bool enable_oob_load_report() const { return enable_oob_load_report_; }
+  Duration oob_reporting_period() const { return oob_reporting_period_; }
+  Duration blackout_period() const { return blackout_period_; }
+  Duration weight_update_period() const { return weight_update_period_; }
+  Duration weight_expiration_period() const {
+    return weight_expiration_period_;
   }
-  weight_->MaybeUpdateWeight(backend_metric_data.qps, backend_metric_data.eps,
-                             utilization, error_utilization_penalty_);
-}
-
-//
-// OldWeightedRoundRobin::WeightedRoundRobinSubchannelData
-//
+  float error_utilization_penalty() const { return error_utilization_penalty_; }
 
-OldWeightedRoundRobin::WeightedRoundRobinSubchannelData::
-    WeightedRoundRobinSubchannelData(
-        SubchannelList<WeightedRoundRobinSubchannelList,
-                       WeightedRoundRobinSubchannelData>* subchannel_list,
-        const ServerAddress& address, RefCountedPtr<SubchannelInterface> sc)
-    : SubchannelData(subchannel_list, address, std::move(sc)),
-      weight_(static_cast<OldWeightedRoundRobin*>(subchannel_list->policy())
-                  ->GetOrCreateWeight(address.address())) {
-  // Start OOB watch if configured.
-  OldWeightedRoundRobin* p =
-      static_cast<OldWeightedRoundRobin*>(subchannel_list->policy());
-  if (p->config_->enable_oob_load_report()) {
-    subchannel()->AddDataWatcher(MakeOobBackendMetricWatcher(
-        p->config_->oob_reporting_period(),
-        std::make_unique<OobWatcher>(weight_,
-                                     p->config_->error_utilization_penalty())));
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader =
+        JsonObjectLoader<WeightedRoundRobinConfig>()
+            .OptionalField("enableOobLoadReport",
+                           &WeightedRoundRobinConfig::enable_oob_load_report_)
+            .OptionalField("oobReportingPeriod",
+                           &WeightedRoundRobinConfig::oob_reporting_period_)
+            .OptionalField("blackoutPeriod",
+                           &WeightedRoundRobinConfig::blackout_period_)
+            .OptionalField("weightUpdatePeriod",
+                           &WeightedRoundRobinConfig::weight_update_period_)
+            .OptionalField("weightExpirationPeriod",
+                           &WeightedRoundRobinConfig::weight_expiration_period_)
+            .OptionalField(
+                "errorUtilizationPenalty",
+                &WeightedRoundRobinConfig::error_utilization_penalty_)
+            .Finish();
+    return loader;
   }
-}
 
-void OldWeightedRoundRobin::WeightedRoundRobinSubchannelData::
-    ProcessConnectivityChangeLocked(
-        absl::optional<grpc_connectivity_state> old_state,
-        grpc_connectivity_state new_state) {
-  OldWeightedRoundRobin* p =
-      static_cast<OldWeightedRoundRobin*>(subchannel_list()->policy());
-  GPR_ASSERT(subchannel() != nullptr);
-  // If this is not the initial state notification and the new state is
-  // TRANSIENT_FAILURE or IDLE, re-resolve.
-  // Note that we don't want to do this on the initial state notification,
-  // because that would result in an endless loop of re-resolution.
-  if (old_state.has_value() && (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
-                                new_state == GRPC_CHANNEL_IDLE)) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO,
-              "[WRR %p] Subchannel %p reported %s; requesting re-resolution", p,
-              subchannel(), ConnectivityStateName(new_state));
-    }
-    p->channel_control_helper()->RequestReresolution();
-  }
-  if (new_state == GRPC_CHANNEL_IDLE) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO,
-              "[WRR %p] Subchannel %p reported IDLE; requesting connection", p,
-              subchannel());
-    }
-    subchannel()->RequestConnection();
-  } else if (new_state == GRPC_CHANNEL_READY) {
-    // If we transition back to READY state, restart the blackout period.
-    // Skip this if this is the initial notification for this
-    // subchannel (which happens whenever we get updated addresses and
-    // create a new endpoint list).  Also skip it if the previous state
-    // was READY (which should never happen in practice, but we've seen
-    // at least one bug that caused this in the outlier_detection
-    // policy, so let's be defensive here).
-    //
-    // Note that we cannot guarantee that we will never receive
-    // lingering callbacks for backend metric reports from the previous
-    // connection after the new connection has been established, but they
-    // should be masked by new backend metric reports from the new
-    // connection by the time the blackout period ends.
-    if (old_state.has_value() && old_state != GRPC_CHANNEL_READY) {
-      weight_->ResetNonEmptySince();
+  void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
+    // Impose lower bound of 100ms on weightUpdatePeriod.
+    weight_update_period_ =
+        std::max(weight_update_period_, Duration::Milliseconds(100));
+    if (error_utilization_penalty_ < 0) {
+      ValidationErrors::ScopedField field(errors, ".errorUtilizationPenalty");
+      errors->AddError("must be non-negative");
     }
   }
-  // Update logical connectivity state.
-  UpdateLogicalConnectivityStateLocked(new_state);
-  // Update the policy state.
-  subchannel_list()->MaybeUpdateAggregatedConnectivityStateLocked(
-      connectivity_status());
-}
 
-void OldWeightedRoundRobin::WeightedRoundRobinSubchannelData::
-    UpdateLogicalConnectivityStateLocked(
-        grpc_connectivity_state connectivity_state) {
-  OldWeightedRoundRobin* p =
-      static_cast<OldWeightedRoundRobin*>(subchannel_list()->policy());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(
-        GPR_INFO,
-        "[WRR %p] connectivity changed for subchannel %p, subchannel_list %p "
-        "(index %" PRIuPTR " of %" PRIuPTR "): prev_state=%s new_state=%s",
-        p, subchannel(), subchannel_list(), Index(),
-        subchannel_list()->num_subchannels(),
-        (logical_connectivity_state_.has_value()
-             ? ConnectivityStateName(*logical_connectivity_state_)
-             : "N/A"),
-        ConnectivityStateName(connectivity_state));
-  }
-  // Decide what state to report for aggregation purposes.
-  // If the last logical state was TRANSIENT_FAILURE, then ignore the
-  // state change unless the new state is READY.
-  if (logical_connectivity_state_.has_value() &&
-      *logical_connectivity_state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
-      connectivity_state != GRPC_CHANNEL_READY) {
-    return;
-  }
-  // If the new state is IDLE, treat it as CONNECTING, since it will
-  // immediately transition into CONNECTING anyway.
-  if (connectivity_state == GRPC_CHANNEL_IDLE) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO,
-              "[WRR %p] subchannel %p, subchannel_list %p (index %" PRIuPTR
-              " of %" PRIuPTR "): treating IDLE as CONNECTING",
-              p, subchannel(), subchannel_list(), Index(),
-              subchannel_list()->num_subchannels());
-    }
-    connectivity_state = GRPC_CHANNEL_CONNECTING;
-  }
-  // If no change, return false.
-  if (logical_connectivity_state_.has_value() &&
-      *logical_connectivity_state_ == connectivity_state) {
-    return;
-  }
-  // Otherwise, update counters and logical state.
-  subchannel_list()->UpdateStateCountersLocked(logical_connectivity_state_,
-                                               connectivity_state);
-  logical_connectivity_state_ = connectivity_state;
-}
+ private:
+  bool enable_oob_load_report_ = false;
+  Duration oob_reporting_period_ = Duration::Seconds(10);
+  Duration blackout_period_ = Duration::Seconds(10);
+  Duration weight_update_period_ = Duration::Seconds(1);
+  Duration weight_expiration_period_ = Duration::Minutes(3);
+  float error_utilization_penalty_ = 1.0;
+};
 
-// New WRR LB policy (with delegation to pick_first)
-class WeightedRoundRobin : public LoadBalancingPolicy {
+// WRR LB policy
+class WeightedRoundRobin final : public LoadBalancingPolicy {
  public:
   explicit WeightedRoundRobin(Args args);
 
@@ -1010,7 +190,7 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
 
  private:
   // Represents the weight for a given address.
-  class EndpointWeight : public RefCounted<EndpointWeight> {
+  class EndpointWeight final : public RefCounted<EndpointWeight> {
    public:
     EndpointWeight(RefCountedPtr<WeightedRoundRobin> wrr,
                    EndpointAddressSet key)
@@ -1021,7 +201,8 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
                            float error_utilization_penalty);
 
     float GetWeight(Timestamp now, Duration weight_expiration_period,
-                    Duration blackout_period);
+                    Duration blackout_period, uint64_t* num_not_yet_usable,
+                    uint64_t* num_stale);
 
     void ResetNonEmptySince();
 
@@ -1032,26 +213,31 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
     Mutex mu_;
     float weight_ ABSL_GUARDED_BY(&mu_) = 0;
     Timestamp non_empty_since_ ABSL_GUARDED_BY(&mu_) = Timestamp::InfFuture();
-    Timestamp last_update_time_ ABSL_GUARDED_BY(&mu_) = Timestamp::InfPast();
+    Timestamp last_update_time_ ABSL_GUARDED_BY(&mu_) = Timestamp::InfFuture();
   };
 
-  class WrrEndpointList : public EndpointList {
+  class WrrEndpointList final : public EndpointList {
    public:
-    class WrrEndpoint : public Endpoint {
+    class WrrEndpoint final : public Endpoint {
      public:
       WrrEndpoint(RefCountedPtr<EndpointList> endpoint_list,
                   const EndpointAddresses& addresses, const ChannelArgs& args,
-                  std::shared_ptr<WorkSerializer> work_serializer)
+                  std::shared_ptr<WorkSerializer> work_serializer,
+                  std::vector<std::string>* errors)
           : Endpoint(std::move(endpoint_list)),
             weight_(policy<WeightedRoundRobin>()->GetOrCreateWeight(
                 addresses.addresses())) {
-        Init(addresses, args, std::move(work_serializer));
+        absl::Status status = Init(addresses, args, std::move(work_serializer));
+        if (!status.ok()) {
+          errors->emplace_back(absl::StrCat("endpoint ", addresses.ToString(),
+                                            ": ", status.ToString()));
+        }
       }
 
       RefCountedPtr<EndpointWeight> weight() const { return weight_; }
 
      private:
-      class OobWatcher : public OobBackendMetricWatcher {
+      class OobWatcher final : public OobBackendMetricWatcher {
        public:
         OobWatcher(RefCountedPtr<EndpointWeight> weight,
                    float error_utilization_penalty)
@@ -1081,7 +267,7 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
 
     WrrEndpointList(RefCountedPtr<WeightedRoundRobin> wrr,
                     EndpointAddressesIterator* endpoints,
-                    const ChannelArgs& args)
+                    const ChannelArgs& args, std::vector<std::string>* errors)
         : EndpointList(std::move(wrr),
                        GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)
                            ? "WrrEndpointList"
@@ -1091,7 +277,7 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
                const EndpointAddresses& addresses, const ChannelArgs& args) {
              return MakeOrphanable<WrrEndpoint>(
                  std::move(endpoint_list), addresses, args,
-                 policy<WeightedRoundRobin>()->work_serializer());
+                 policy<WeightedRoundRobin>()->work_serializer(), errors);
            });
     }
 
@@ -1128,7 +314,7 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
 
   // A picker that performs WRR picks with weights based on
   // endpoint-reported utilization and QPS.
-  class Picker : public SubchannelPicker {
+  class Picker final : public SubchannelPicker {
    public:
     Picker(RefCountedPtr<WeightedRoundRobin> wrr,
            WrrEndpointList* endpoint_list);
@@ -1137,11 +323,9 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
 
     PickResult Pick(PickArgs args) override;
 
-    void Orphan() override;
-
    private:
     // A call tracker that collects per-call endpoint utilization reports.
-    class SubchannelCallTracker : public SubchannelCallTrackerInterface {
+    class SubchannelCallTracker final : public SubchannelCallTrackerInterface {
      public:
       SubchannelCallTracker(
           RefCountedPtr<EndpointWeight> weight, float error_utilization_penalty,
@@ -1170,6 +354,8 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
       RefCountedPtr<EndpointWeight> weight;
     };
 
+    void Orphaned() override;
+
     // Returns the index into endpoints_ to be picked.
     size_t PickIndex();
 
@@ -1215,6 +401,8 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
   std::map<EndpointAddressSet, EndpointWeight*> endpoint_weight_map_
       ABSL_GUARDED_BY(&endpoint_weight_map_mu_);
 
+  const absl::string_view locality_name_;
+
   bool shutdown_ = false;
 
   absl::BitGen bit_gen_;
@@ -1276,8 +464,8 @@ void WeightedRoundRobin::EndpointWeight::MaybeUpdateWeight(
 }
 
 float WeightedRoundRobin::EndpointWeight::GetWeight(
-    Timestamp now, Duration weight_expiration_period,
-    Duration blackout_period) {
+    Timestamp now, Duration weight_expiration_period, Duration blackout_period,
+    uint64_t* num_not_yet_usable, uint64_t* num_stale) {
   MutexLock lock(&mu_);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
     gpr_log(GPR_INFO,
@@ -1294,12 +482,14 @@ float WeightedRoundRobin::EndpointWeight::GetWeight(
   // period, reset non_empty_since_ so that we apply the blackout period
   // again if we start getting data again in the future, and return 0.
   if (now - last_update_time_ >= weight_expiration_period) {
+    ++*num_stale;
     non_empty_since_ = Timestamp::InfFuture();
     return 0;
   }
   // If we don't have at least blackout_period worth of data, return 0.
   if (blackout_period > Duration::Zero() &&
       now - non_empty_since_ < blackout_period) {
+    ++*num_not_yet_usable;
     return 0;
   }
   // Otherwise, return the weight.
@@ -1370,7 +560,7 @@ WeightedRoundRobin::Picker::~Picker() {
   }
 }
 
-void WeightedRoundRobin::Picker::Orphan() {
+void WeightedRoundRobin::Picker::Orphaned() {
   MutexLock lock(&timer_mu_);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
     gpr_log(GPR_INFO, "[WRR %p picker %p] cancelling timer", wrr_.get(), this);
@@ -1382,7 +572,7 @@ void WeightedRoundRobin::Picker::Orphan() {
 
 WeightedRoundRobin::PickResult WeightedRoundRobin::Picker::Pick(PickArgs args) {
   size_t index = PickIndex();
-  GPR_ASSERT(index < endpoints_.size());
+  CHECK(index < endpoints_.size());
   auto& endpoint_info = endpoints_[index];
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
     gpr_log(GPR_INFO,
@@ -1418,14 +608,28 @@ size_t WeightedRoundRobin::Picker::PickIndex() {
 }
 
 void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
-  // Build scheduler.
+  auto& stats_plugins = wrr_->channel_control_helper()->GetStatsPluginGroup();
+  // Build scheduler, reporting metrics on endpoint weights.
   const Timestamp now = Timestamp::Now();
   std::vector<float> weights;
   weights.reserve(endpoints_.size());
+  uint64_t num_not_yet_usable = 0;
+  uint64_t num_stale = 0;
   for (const auto& endpoint : endpoints_) {
-    weights.push_back(endpoint.weight->GetWeight(
-        now, config_->weight_expiration_period(), config_->blackout_period()));
-  }
+    float weight = endpoint.weight->GetWeight(
+        now, config_->weight_expiration_period(), config_->blackout_period(),
+        &num_not_yet_usable, &num_stale);
+    weights.push_back(weight);
+    stats_plugins.RecordHistogram(kMetricEndpointWeights, weight,
+                                  {wrr_->channel_control_helper()->GetTarget()},
+                                  {wrr_->locality_name_});
+  }
+  stats_plugins.AddCounter(
+      kMetricEndpointWeightNotYetUsable, num_not_yet_usable,
+      {wrr_->channel_control_helper()->GetTarget()}, {wrr_->locality_name_});
+  stats_plugins.AddCounter(kMetricEndpointWeightStale, num_stale,
+                           {wrr_->channel_control_helper()->GetTarget()},
+                           {wrr_->locality_name_});
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
     gpr_log(GPR_INFO, "[WRR %p picker %p] new weights: %s", wrr_.get(), this,
             absl::StrJoin(weights, " ").c_str());
@@ -1440,9 +644,14 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
       gpr_log(GPR_INFO, "[WRR %p picker %p] new scheduler: %p", wrr_.get(),
               this, scheduler.get());
     }
-  } else if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] no scheduler, falling back to RR",
-            wrr_.get(), this);
+  } else {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
+      gpr_log(GPR_INFO, "[WRR %p picker %p] no scheduler, falling back to RR",
+              wrr_.get(), this);
+    }
+    stats_plugins.AddCounter(kMetricRrFallback, 1,
+                             {wrr_->channel_control_helper()->GetTarget()},
+                             {wrr_->locality_name_});
   }
   {
     MutexLock lock(&scheduler_mu_);
@@ -1483,9 +692,13 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
 //
 
 WeightedRoundRobin::WeightedRoundRobin(Args args)
-    : LoadBalancingPolicy(std::move(args)) {
+    : LoadBalancingPolicy(std::move(args)),
+      locality_name_(channel_args()
+                         .GetString(GRPC_ARG_LB_WEIGHTED_TARGET_CHILD)
+                         .value_or("")) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-    gpr_log(GPR_INFO, "[WRR %p] Created", this);
+    gpr_log(GPR_INFO, "[WRR %p] Created -- locality_name=\"%s\"", this,
+            std::string(locality_name_).c_str());
   }
 }
 
@@ -1493,8 +706,8 @@ WeightedRoundRobin::~WeightedRoundRobin() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
     gpr_log(GPR_INFO, "[WRR %p] Destroying Round Robin policy", this);
   }
-  GPR_ASSERT(endpoint_list_ == nullptr);
-  GPR_ASSERT(latest_pending_endpoint_list_ == nullptr);
+  CHECK(endpoint_list_ == nullptr);
+  CHECK(latest_pending_endpoint_list_ == nullptr);
 }
 
 void WeightedRoundRobin::ShutdownLocked() {
@@ -1560,8 +773,9 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
     gpr_log(GPR_INFO, "[WRR %p] replacing previous pending endpoint list %p",
             this, latest_pending_endpoint_list_.get());
   }
+  std::vector<std::string> errors;
   latest_pending_endpoint_list_ = MakeOrphanable<WrrEndpointList>(
-      RefAsSubclass<WeightedRoundRobin>(), addresses.get(), args.args);
+      RefAsSubclass<WeightedRoundRobin>(), addresses.get(), args.args, &errors);
   // If the new list is empty, immediately promote it to
   // endpoint_list_ and report TRANSIENT_FAILURE.
   if (latest_pending_endpoint_list_->size() == 0) {
@@ -1585,6 +799,10 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
   if (endpoint_list_.get() == nullptr) {
     endpoint_list_ = std::move(latest_pending_endpoint_list_);
   }
+  if (!errors.empty()) {
+    return absl::UnavailableError(absl::StrCat(
+        "errors from children: [", absl::StrJoin(errors, "; "), "]"));
+  }
   return absl::OkStatus();
 }
 
@@ -1696,20 +914,20 @@ void WeightedRoundRobin::WrrEndpointList::UpdateStateCountersLocked(
   // We treat IDLE the same as CONNECTING, since it will immediately
   // transition into that state anyway.
   if (old_state.has_value()) {
-    GPR_ASSERT(*old_state != GRPC_CHANNEL_SHUTDOWN);
+    CHECK(*old_state != GRPC_CHANNEL_SHUTDOWN);
     if (*old_state == GRPC_CHANNEL_READY) {
-      GPR_ASSERT(num_ready_ > 0);
+      CHECK_GT(num_ready_, 0u);
       --num_ready_;
     } else if (*old_state == GRPC_CHANNEL_CONNECTING ||
                *old_state == GRPC_CHANNEL_IDLE) {
-      GPR_ASSERT(num_connecting_ > 0);
+      CHECK_GT(num_connecting_, 0u);
       --num_connecting_;
     } else if (*old_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-      GPR_ASSERT(num_transient_failure_ > 0);
+      CHECK_GT(num_transient_failure_, 0u);
       --num_transient_failure_;
     }
   }
-  GPR_ASSERT(new_state != GRPC_CHANNEL_SHUTDOWN);
+  CHECK(new_state != GRPC_CHANNEL_SHUTDOWN);
   if (new_state == GRPC_CHANNEL_READY) {
     ++num_ready_;
   } else if (new_state == GRPC_CHANNEL_CONNECTING ||
@@ -1789,13 +1007,10 @@ void WeightedRoundRobin::WrrEndpointList::
 // factory
 //
 
-class WeightedRoundRobinFactory : public LoadBalancingPolicyFactory {
+class WeightedRoundRobinFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {
-    if (!IsWrrDelegateToPickFirstEnabled()) {
-      return MakeOrphanable<OldWeightedRoundRobin>(std::move(args));
-    }
     return MakeOrphanable<WeightedRoundRobin>(std::move(args));
   }