grpc 1.55.3 → 1.56.0.pre3

data/src/core/ext/filters/client_channel/lb_policy/weighted_round_robin/static_stride_scheduler.cc

@@ -31,7 +31,50 @@
 namespace grpc_core {
 
 namespace {
+
 constexpr uint16_t kMaxWeight = std::numeric_limits<uint16_t>::max();
+
+// Assuming the mean of all known weights is M, StaticStrideScheduler will cap
+// from above all known weights that are bigger than M*kMaxRatio (to
+// M*kMaxRatio).
+//
+// This is done to limit the number of rounds for picks.
+constexpr double kMaxRatio = 10;
+
+// Assuming the mean of all known weights is M, StaticStrideScheduler will cap
+// from below all known weights to M*kMinRatio.
+//
+// This is done as a performance optimization for edge cases when channels with
+// large weights are non-accepting (and thus WeightedRoundRobin will retry
+// picking them over and over again), and there are also channels with near-zero
+// weights that are possibly accepting. In this case, without kMinRatio, it
+// would potentially require WeightedRoundRobin to perform thousands of picks
+// until it gets a single channel with near-zero weight. This was a part of what
+// hapenned in b/276292666.
+//
+// The current value of 0.01 was chosen without any experimenting. It should
+// ensure that WeightedRoundRobin doesn't do much more than an order of 100
+// picks of non-accepting channels with high weights in such corner cases. But
+// it also makes WeightedRoundRobin to send slightly more requests to
+// potentially very bad tasks (that would have near-zero weights) than zero.
+// This is not necesserily a downside, though. Perhaps this is not a problem at
+// all and we should increase this value (to 0.05 or 0.1) to save CPU cycles.
+//
+// Note that this class treats weights that are exactly equal to zero as unknown
+// and thus needing to be replaced with M. This behavior itself makes sense
+// (fresh channels without feedback information will get an average flow of
+// requests). However, it follows from this that this class will replace weight
+// = 0 with M, but weight = epsilon with M*kMinRatio, and this step function is
+// logically faulty. A demonstration of this is that the function that computes
+// weights in WeightedRoundRobin
+// (http://google3/production/rpc/stubs/core/loadbalancing/weightedroundrobin.cc;l=324-325;rcl=514986476)
+// will cap some epsilon values to zero. There should be a clear distinction
+// between "task is new, weight is unknown" and "task is unhealthy, weight is
+// very low". A better solution would be to not mix "unknown" and "weight" into
+// a single value but represent weights as std::optional<float> or, if memory
+// usage is a concern, use NaN as the indicator of unknown weight.
+constexpr double kMinRatio = 0.01;
+
 }  // namespace
 
 absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
@@ -45,10 +88,10 @@ absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
   const size_t n = float_weights.size();
   size_t num_zero_weight_channels = 0;
   double sum = 0;
-  float max = 0;
+  float unscaled_max = 0;
   for (const float weight : float_weights) {
     sum += weight;
-    max = std::max(max, weight);
+    unscaled_max = std::max(unscaled_max, weight);
     if (weight == 0) {
       ++num_zero_weight_channels;
     }
@@ -59,6 +102,13 @@ absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
   // Mean of non-zero weights before scaling to `kMaxWeight`.
   const double unscaled_mean =
       sum / static_cast<double>(n - num_zero_weight_channels);
+  const double ratio = unscaled_max / unscaled_mean;
+
+  // Adjust max value such that ratio does not exceed kMaxRatio. This should
+  // ensure that we on average do at most kMaxRatio rounds for picks.
+  if (ratio > kMaxRatio) {
+    unscaled_max = kMaxRatio * unscaled_mean;
+  }
 
   // Scale weights such that the largest is equal to `kMaxWeight`. This should
   // be accurate enough once we convert to an integer. Quantisation errors won't
@@ -66,15 +116,35 @@ absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
   // TODO(b/190488683): it may be more stable over updates if we try to keep
   // `scaling_factor` consistent, and only change it when we can't accurately
   // represent the new weights.
-  const double scaling_factor = kMaxWeight / max;
+  const double scaling_factor = kMaxWeight / unscaled_max;
+
+  // Note that since we cap the weights to stay within kMaxRatio, `mean` might
+  // not match the actual mean of the values that end up in the scheduler.
   const uint16_t mean = std::lround(scaling_factor * unscaled_mean);
 
+  // We compute weight_lower_bound and cap it to 1 from below so that in the
+  // worst case we represent tiny weights as 1 but not as 0 (which would cause
+  // an infinite loop as in b/276292666). This capping to 1 is probably only
+  // useful in case someone misconfigures kMinRatio to be very small.
+  //
+  // NOMUTANTS -- We have tests for this expression, but they are not precise
+  // enough to catch errors of plus/minus 1, what mutation testing does.
+  const uint16_t weight_lower_bound =
+      std::max(static_cast<uint16_t>(1),
+               static_cast<uint16_t>(std::lround(mean * kMinRatio)));
+
   std::vector<uint16_t> weights;
   weights.reserve(n);
   for (size_t i = 0; i < n; ++i) {
-    weights.push_back(float_weights[i] == 0
-                          ? mean
-                          : std::lround(float_weights[i] * scaling_factor));
+    if (float_weights[i] == 0) {  // Weight is unknown.
+      weights.push_back(mean);
+    } else {
+      const double float_weight_capped_from_above =
+          std::min(float_weights[i], unscaled_max);
+      const uint16_t weight =
+          std::lround(float_weight_capped_from_above * scaling_factor);
+      weights.push_back(std::max(weight, weight_lower_bound));
+    }
   }
 
   GPR_ASSERT(weights.size() == float_weights.size());

data/src/core/ext/filters/client_channel/lb_policy/weighted_round_robin/weighted_round_robin.cc

@@ -59,6 +59,7 @@
 #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"
@@ -157,7 +158,7 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
         : wrr_(std::move(wrr)), key_(std::move(key)) {}
     ~AddressWeight() override;
 
-    void MaybeUpdateWeight(double qps, double eps, double cpu_utilization,
+    void MaybeUpdateWeight(double qps, double eps, double utilization,
                            float error_utilization_penalty);
 
     float GetWeight(Timestamp now, Duration weight_expiration_period,
@@ -271,6 +272,10 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
         absl::Status status_for_tf);
 
    private:
+    std::shared_ptr<WorkSerializer> work_serializer() const override {
+      return static_cast<WeightedRoundRobin*>(policy())->work_serializer();
+    }
+
     std::string CountersString() const {
       return absl::StrCat("num_subchannels=", num_subchannels(),
                           " num_ready=", num_ready_,
@@ -335,11 +340,7 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&timer_mu_);
 
     RefCountedPtr<WeightedRoundRobin> wrr_;
-    const bool use_per_rpc_utilization_;
-    const Duration weight_update_period_;
-    const Duration weight_expiration_period_;
-    const Duration blackout_period_;
-    const float error_utilization_penalty_;
+    RefCountedPtr<WeightedRoundRobinConfig> config_;
     std::vector<SubchannelInfo> subchannels_;
 
     Mutex scheduler_mu_;
@@ -397,23 +398,23 @@ WeightedRoundRobin::AddressWeight::~AddressWeight() {
 }
 
 void WeightedRoundRobin::AddressWeight::MaybeUpdateWeight(
-    double qps, double eps, double cpu_utilization,
+    double qps, double eps, double utilization,
     float error_utilization_penalty) {
   // Compute weight.
   float weight = 0;
-  if (qps > 0 && cpu_utilization > 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 / (cpu_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, cpu_utilization=%f: "
+              "[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, cpu_utilization,
+              wrr_.get(), key_.c_str(), qps, eps, utilization,
               error_utilization_penalty, weight);
     }
     return;
@@ -423,10 +424,10 @@ void WeightedRoundRobin::AddressWeight::MaybeUpdateWeight(
   MutexLock lock(&mu_);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
     gpr_log(GPR_INFO,
-            "[WRR %p] subchannel %s: qps=%f, eps=%f, cpu_utilization=%f "
+            "[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, cpu_utilization,
+            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());
@@ -482,14 +483,16 @@ void WeightedRoundRobin::Picker::SubchannelCallTracker::Finish(
       args.backend_metric_accessor->GetBackendMetricData();
   double qps = 0;
   double eps = 0;
-  double cpu_utilization = 0;
+  double utilization = 0;
   if (backend_metric_data != nullptr) {
     qps = backend_metric_data->qps;
     eps = backend_metric_data->eps;
-    cpu_utilization = backend_metric_data->cpu_utilization;
+    utilization = backend_metric_data->application_utilization;
+    if (utilization <= 0) {
+      utilization = backend_metric_data->cpu_utilization;
+    }
   }
-  weight_->MaybeUpdateWeight(qps, eps, cpu_utilization,
-                             error_utilization_penalty_);
+  weight_->MaybeUpdateWeight(qps, eps, utilization, error_utilization_penalty_);
 }
 
 //
@@ -500,11 +503,7 @@ WeightedRoundRobin::Picker::Picker(
     RefCountedPtr<WeightedRoundRobin> wrr,
     WeightedRoundRobinSubchannelList* subchannel_list)
     : wrr_(std::move(wrr)),
-      use_per_rpc_utilization_(!wrr_->config_->enable_oob_load_report()),
-      weight_update_period_(wrr_->config_->weight_update_period()),
-      weight_expiration_period_(wrr_->config_->weight_expiration_period()),
-      blackout_period_(wrr_->config_->blackout_period()),
-      error_utilization_penalty_(wrr_->config_->error_utilization_penalty()),
+      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);
@@ -543,9 +542,9 @@ WeightedRoundRobin::PickResult WeightedRoundRobin::Picker::Pick(
   auto& subchannel_info = subchannels_[index];
   // Collect per-call utilization data if needed.
   std::unique_ptr<SubchannelCallTrackerInterface> subchannel_call_tracker;
-  if (use_per_rpc_utilization_) {
+  if (!config_->enable_oob_load_report()) {
     subchannel_call_tracker = std::make_unique<SubchannelCallTracker>(
-        subchannel_info.weight, error_utilization_penalty_);
+        subchannel_info.weight, config_->error_utilization_penalty());
   }
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
     gpr_log(GPR_INFO,
@@ -577,7 +576,7 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
   weights.reserve(subchannels_.size());
   for (const auto& subchannel : subchannels_) {
     weights.push_back(subchannel.weight->GetWeight(
-        now, weight_expiration_period_, blackout_period_));
+        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,
@@ -604,7 +603,7 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
   // Start timer.
   WeakRefCountedPtr<Picker> self = WeakRef();
   timer_handle_ = wrr_->channel_control_helper()->GetEventEngine()->RunAfter(
-      weight_update_period_, [self = std::move(self)]() mutable {
+      config_->weight_update_period(), [self = std::move(self)]() mutable {
         ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         {
@@ -724,12 +723,9 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
     return status;
   }
   // Otherwise, if this is the initial update, immediately promote it to
-  // subchannel_list_ and report CONNECTING.
+  // subchannel_list_.
   if (subchannel_list_.get() == nullptr) {
     subchannel_list_ = std::move(latest_pending_subchannel_list_);
-    channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_CONNECTING, absl::Status(),
-        MakeRefCounted<QueuePicker>(Ref(DEBUG_LOCATION, "QueuePicker")));
   }
   return absl::OkStatus();
 }
@@ -853,9 +849,12 @@ void WeightedRoundRobin::WeightedRoundRobinSubchannelList::
 
 void WeightedRoundRobin::WeightedRoundRobinSubchannelData::OobWatcher::
     OnBackendMetricReport(const BackendMetricData& backend_metric_data) {
+  double utilization = backend_metric_data.application_utilization;
+  if (utilization <= 0) {
+    utilization = backend_metric_data.cpu_utilization;
+  }
   weight_->MaybeUpdateWeight(backend_metric_data.qps, backend_metric_data.eps,
-                             backend_metric_data.cpu_utilization,
-                             error_utilization_penalty_);
+                             utilization, error_utilization_penalty_);
 }
 
 //
@@ -987,13 +986,7 @@ class WeightedRoundRobinFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::kNull) {
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:weighted_round_robin policy "
-          "requires configuration. Please use loadBalancingConfig field of "
-          "service config instead.");
-    }
-    return LoadRefCountedFromJson<WeightedRoundRobinConfig>(
+    return LoadFromJson<RefCountedPtr<WeightedRoundRobinConfig>>(
         json, JsonArgs(),
         "errors validating weighted_round_robin LB policy config");
   }

data/src/core/ext/filters/client_channel/lb_policy/weighted_target/weighted_target.cc

@@ -519,7 +519,9 @@ void WeightedTargetLb::WeightedChild::DelayedRemovalTimer::OnTimerLocked() {
 WeightedTargetLb::WeightedChild::WeightedChild(
     RefCountedPtr<WeightedTargetLb> weighted_target_policy,
     const std::string& name)
-    : weighted_target_policy_(std::move(weighted_target_policy)), name_(name) {
+    : weighted_target_policy_(std::move(weighted_target_policy)),
+      name_(name),
+      picker_(MakeRefCounted<QueuePicker>(nullptr)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_weighted_target_trace)) {
     gpr_log(GPR_INFO, "[weighted_target_lb %p] created WeightedChild %p for %s",
             weighted_target_policy_.get(), this, name_.c_str());
@@ -764,15 +766,7 @@ class WeightedTargetLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::kNull) {
-      // weighted_target was mentioned as a policy in the deprecated
-      // loadBalancingPolicy field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:weighted_target policy requires "
-          "configuration.  Please use loadBalancingConfig field of service "
-          "config instead.");
-    }
-    return LoadRefCountedFromJson<WeightedTargetLbConfig>(
+    return LoadFromJson<RefCountedPtr<WeightedTargetLbConfig>>(
         json, JsonArgs(), "errors validating weighted_target LB policy config");
   }
 };

data/src/core/ext/filters/client_channel/lb_policy/xds/cds.cc

@@ -36,6 +36,7 @@
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/impl/connectivity_state.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
@@ -406,59 +407,68 @@ absl::StatusOr<bool> CdsLb::GenerateDiscoveryMechanismForCluster(
     return !missing_cluster;
   }
   Json::Object mechanism = {
-      {"clusterName", name},
-      {"max_concurrent_requests", state.update->max_concurrent_requests},
+      {"clusterName", Json::FromString(name)},
+      {"max_concurrent_requests",
+       Json::FromNumber(state.update->max_concurrent_requests)},
   };
   if (state.update->outlier_detection.has_value()) {
     auto& outlier_detection_update = state.update->outlier_detection.value();
     Json::Object outlier_detection;
     outlier_detection["interval"] =
-        outlier_detection_update.interval.ToJsonString();
-    outlier_detection["baseEjectionTime"] =
-        outlier_detection_update.base_ejection_time.ToJsonString();
-    outlier_detection["maxEjectionTime"] =
-        outlier_detection_update.max_ejection_time.ToJsonString();
+        Json::FromString(outlier_detection_update.interval.ToJsonString());
+    outlier_detection["baseEjectionTime"] = Json::FromString(
+        outlier_detection_update.base_ejection_time.ToJsonString());
+    outlier_detection["maxEjectionTime"] = Json::FromString(
+        outlier_detection_update.max_ejection_time.ToJsonString());
     outlier_detection["maxEjectionPercent"] =
-        outlier_detection_update.max_ejection_percent;
+        Json::FromNumber(outlier_detection_update.max_ejection_percent);
     if (outlier_detection_update.success_rate_ejection.has_value()) {
-      outlier_detection["successRateEjection"] = Json::Object{
+      outlier_detection["successRateEjection"] = Json::FromObject({
           {"stdevFactor",
-           outlier_detection_update.success_rate_ejection->stdev_factor},
+           Json::FromNumber(
+               outlier_detection_update.success_rate_ejection->stdev_factor)},
           {"enforcementPercentage",
-           outlier_detection_update.success_rate_ejection
-               ->enforcement_percentage},
+           Json::FromNumber(outlier_detection_update.success_rate_ejection
+                                ->enforcement_percentage)},
           {"minimumHosts",
-           outlier_detection_update.success_rate_ejection->minimum_hosts},
+           Json::FromNumber(
+               outlier_detection_update.success_rate_ejection->minimum_hosts)},
           {"requestVolume",
-           outlier_detection_update.success_rate_ejection->request_volume},
-      };
+           Json::FromNumber(
+               outlier_detection_update.success_rate_ejection->request_volume)},
+      });
     }
     if (outlier_detection_update.failure_percentage_ejection.has_value()) {
-      outlier_detection["failurePercentageEjection"] = Json::Object{
+      outlier_detection["failurePercentageEjection"] = Json::FromObject({
           {"threshold",
-           outlier_detection_update.failure_percentage_ejection->threshold},
+           Json::FromNumber(outlier_detection_update
+                                .failure_percentage_ejection->threshold)},
           {"enforcementPercentage",
-           outlier_detection_update.failure_percentage_ejection
-               ->enforcement_percentage},
+           Json::FromNumber(
+               outlier_detection_update.failure_percentage_ejection
+                   ->enforcement_percentage)},
           {"minimumHosts",
-           outlier_detection_update.failure_percentage_ejection->minimum_hosts},
-          {"requestVolume", outlier_detection_update
-                                .failure_percentage_ejection->request_volume},
-      };
+           Json::FromNumber(outlier_detection_update
+                                .failure_percentage_ejection->minimum_hosts)},
+          {"requestVolume",
+           Json::FromNumber(outlier_detection_update
+                                .failure_percentage_ejection->request_volume)},
+      });
     }
-    mechanism["outlierDetection"] = std::move(outlier_detection);
+    mechanism["outlierDetection"] =
+        Json::FromObject(std::move(outlier_detection));
   }
   Match(
       state.update->type,
       [&](const XdsClusterResource::Eds& eds) {
-        mechanism["type"] = "EDS";
+        mechanism["type"] = Json::FromString("EDS");
         if (!eds.eds_service_name.empty()) {
-          mechanism["edsServiceName"] = eds.eds_service_name;
+          mechanism["edsServiceName"] = Json::FromString(eds.eds_service_name);
         }
       },
       [&](const XdsClusterResource::LogicalDns& logical_dns) {
-        mechanism["type"] = "LOGICAL_DNS";
-        mechanism["dnsHostname"] = logical_dns.hostname;
+        mechanism["type"] = Json::FromString("LOGICAL_DNS");
+        mechanism["dnsHostname"] = Json::FromString(logical_dns.hostname);
       },
       [&](const XdsClusterResource::Aggregate&) { GPR_ASSERT(0); });
   if (state.update->lrs_load_reporting_server.has_value()) {
@@ -468,11 +478,11 @@ absl::StatusOr<bool> CdsLb::GenerateDiscoveryMechanismForCluster(
   if (!state.update->override_host_statuses.empty()) {
     Json::Array status_list;
     for (const auto& status : state.update->override_host_statuses) {
-      status_list.emplace_back(status.ToString());
+      status_list.emplace_back(Json::FromString(status.ToString()));
     }
-    mechanism["overrideHostStatus"] = std::move(status_list);
+    mechanism["overrideHostStatus"] = Json::FromArray(std::move(status_list));
   }
-  discovery_mechanisms->emplace_back(std::move(mechanism));
+  discovery_mechanisms->emplace_back(Json::FromObject(std::move(mechanism)));
   return true;
 }
 
@@ -514,15 +524,17 @@ void CdsLb::OnClusterChanged(const std::string& name,
     auto it = watchers_.find(config_->cluster());
     GPR_ASSERT(it != watchers_.end());
     // Construct config for child policy.
-    Json json = Json::Array{
-        Json::Object{
+    Json json = Json::FromArray({
+        Json::FromObject({
             {"xds_cluster_resolver_experimental",
-             Json::Object{
-                 {"xdsLbPolicy", it->second.update->lb_policy_config},
-                 {"discoveryMechanisms", std::move(discovery_mechanisms)},
-             }},
-        },
-    };
+             Json::FromObject({
+                 {"xdsLbPolicy",
+                  Json::FromArray(it->second.update->lb_policy_config)},
+                 {"discoveryMechanisms",
+                  Json::FromArray(std::move(discovery_mechanisms))},
+             })},
+        }),
+    });
     if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
       gpr_log(GPR_INFO, "[cdslb %p] generated config for child policy: %s",
               this, JsonDump(json, /*indent=*/1).c_str());
@@ -743,14 +755,7 @@ class CdsLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::kNull) {
-      // xds was mentioned as a policy in the deprecated loadBalancingPolicy
-      // field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:cds policy requires configuration. "
-          "Please use loadBalancingConfig field of service config instead.");
-    }
-    return LoadRefCountedFromJson<CdsLbConfig>(
+    return LoadFromJson<RefCountedPtr<CdsLbConfig>>(
         json, JsonArgs(), "errors validating cds LB policy config");
   }
 };

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_impl.cc

@@ -777,15 +777,7 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::kNull) {
-      // This policy was configured in the deprecated loadBalancingPolicy
-      // field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:xds_cluster_impl policy requires "
-          "configuration. Please use loadBalancingConfig field of service "
-          "config instead.");
-    }
-    return LoadRefCountedFromJson<XdsClusterImplLbConfig>(
+    return LoadFromJson<RefCountedPtr<XdsClusterImplLbConfig>>(
         json, JsonArgs(),
         "errors validating xds_cluster_impl LB policy config");
   }

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_manager.cc

@@ -19,6 +19,7 @@
 #include <stddef.h>
 
 #include <algorithm>
+#include <functional>
 #include <map>
 #include <memory>
 #include <string>
@@ -123,8 +124,8 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
   class ClusterPicker : public SubchannelPicker {
    public:
     // Maintains a map of cluster names to pickers.
-    using ClusterMap =
-        std::map<std::string /*cluster_name*/, RefCountedPtr<SubchannelPicker>>;
+    using ClusterMap = std::map<std::string /*cluster_name*/,
+                                RefCountedPtr<SubchannelPicker>, std::less<>>;
 
     // It is required that the keys of cluster_map have to live at least as long
     // as the ClusterPicker instance.
@@ -199,7 +200,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
     OrphanablePtr<LoadBalancingPolicy> child_policy_;
 
     RefCountedPtr<SubchannelPicker> picker_;
-    grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_IDLE;
+    grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_CONNECTING;
 
     // States for delayed removal.
     absl::optional<EventEngine::TaskHandle> delayed_removal_timer_handle_;
@@ -230,9 +231,13 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
 XdsClusterManagerLb::PickResult XdsClusterManagerLb::ClusterPicker::Pick(
     PickArgs args) {
   auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
-  auto cluster_name =
-      call_state->GetCallAttribute(XdsClusterAttributeTypeName());
-  auto it = cluster_map_.find(std::string(cluster_name));
+  auto* cluster_name_attribute = static_cast<XdsClusterAttribute*>(
+      call_state->GetCallAttribute(XdsClusterAttribute::TypeName()));
+  absl::string_view cluster_name;
+  if (cluster_name_attribute != nullptr) {
+    cluster_name = cluster_name_attribute->cluster();
+  }
+  auto it = cluster_map_.find(cluster_name);
   if (it != cluster_map_.end()) {
     return it->second->Pick(args);
   }
@@ -404,7 +409,8 @@ XdsClusterManagerLb::ClusterChild::ClusterChild(
     RefCountedPtr<XdsClusterManagerLb> xds_cluster_manager_policy,
     const std::string& name)
     : xds_cluster_manager_policy_(std::move(xds_cluster_manager_policy)),
-      name_(name) {
+      name_(name),
+      picker_(MakeRefCounted<QueuePicker>(nullptr)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_manager_lb_trace)) {
     gpr_log(GPR_INFO,
             "[xds_cluster_manager_lb %p] created ClusterChild %p for %s",
@@ -672,15 +678,7 @@ class XdsClusterManagerLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::kNull) {
-      // xds_cluster_manager was mentioned as a policy in the deprecated
-      // loadBalancingPolicy field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:xds_cluster_manager policy requires "
-          "configuration.  Please use loadBalancingConfig field of service "
-          "config instead.");
-    }
-    return LoadRefCountedFromJson<XdsClusterManagerLbConfig>(
+    return LoadFromJson<RefCountedPtr<XdsClusterManagerLbConfig>>(
         json, JsonArgs(),
         "errors validating xds_cluster_manager LB policy config");
   }