grpc 1.54.3 → 1.59.2

data/src/core/ext/filters/client_channel/lb_policy/subchannel_list.h

@@ -33,11 +33,13 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/filters/client_channel/lb_policy/health_check_client.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
@@ -154,7 +156,7 @@ class SubchannelData {
   // Starts watching the connectivity state of the subchannel.
   // ProcessConnectivityChangeLocked() will be called whenever the
   // connectivity state changes.
-  void StartConnectivityWatchLocked();
+  void StartConnectivityWatchLocked(const ChannelArgs& args);
 
   // Cancels watching the connectivity state of the subchannel.
   void CancelConnectivityWatchLocked(const char* reason);
@@ -167,8 +169,7 @@ class SubchannelData {
   // The subchannel.
   RefCountedPtr<SubchannelInterface> subchannel_;
   // Will be non-null when the subchannel's state is being watched.
-  SubchannelInterface::ConnectivityStateWatcherInterface* pending_watcher_ =
-      nullptr;
+  SubchannelInterface::DataWatcherInterface* health_watcher_ = nullptr;
   // Data updated by the watcher.
   absl::optional<grpc_connectivity_state> connectivity_state_;
   absl::Status connectivity_status_;
@@ -180,7 +181,7 @@ class SubchannelList : public DualRefCounted<SubchannelListType> {
  public:
   // Starts watching the connectivity state of all subchannels.
   // Must be called immediately after instantiation.
-  void StartWatchingLocked();
+  void StartWatchingLocked(const ChannelArgs& args);
 
   // The number of subchannels in the list.
   size_t num_subchannels() const { return subchannels_.size(); }
@@ -218,6 +219,8 @@ class SubchannelList : public DualRefCounted<SubchannelListType> {
   // For accessing Ref() and Unref().
   friend class SubchannelData<SubchannelListType, SubchannelDataType>;
 
+  virtual std::shared_ptr<WorkSerializer> work_serializer() const = 0;
+
   // Backpointer to owning policy.
   LoadBalancingPolicy* policy_;
 
@@ -251,7 +254,7 @@ void SubchannelData<SubchannelListType, SubchannelDataType>::Watcher::
         GPR_INFO,
         "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
         " (subchannel %p): connectivity changed: old_state=%s, new_state=%s, "
-        "status=%s, shutting_down=%d, pending_watcher=%p",
+        "status=%s, shutting_down=%d, health_watcher=%p",
         subchannel_list_->tracer(), subchannel_list_->policy(),
         subchannel_list_.get(), subchannel_data_->Index(),
         subchannel_list_->num_subchannels(),
@@ -260,10 +263,10 @@ void SubchannelData<SubchannelListType, SubchannelDataType>::Watcher::
              ? ConnectivityStateName(*subchannel_data_->connectivity_state_)
              : "N/A"),
         ConnectivityStateName(new_state), status.ToString().c_str(),
-        subchannel_list_->shutting_down(), subchannel_data_->pending_watcher_);
+        subchannel_list_->shutting_down(), subchannel_data_->health_watcher_);
   }
   if (!subchannel_list_->shutting_down() &&
-      subchannel_data_->pending_watcher_ != nullptr) {
+      subchannel_data_->health_watcher_ != nullptr) {
     absl::optional<grpc_connectivity_state> old_state =
         subchannel_data_->connectivity_state_;
     subchannel_data_->connectivity_state_ = new_state;
@@ -314,8 +317,8 @@ void SubchannelData<SubchannelListType,
 }
 
 template <typename SubchannelListType, typename SubchannelDataType>
-void SubchannelData<SubchannelListType,
-                    SubchannelDataType>::StartConnectivityWatchLocked() {
+void SubchannelData<SubchannelListType, SubchannelDataType>::
+    StartConnectivityWatchLocked(const ChannelArgs& args) {
   if (GPR_UNLIKELY(subchannel_list_->tracer() != nullptr)) {
     gpr_log(GPR_INFO,
             "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
@@ -324,29 +327,29 @@ void SubchannelData<SubchannelListType,
             subchannel_list_, Index(), subchannel_list_->num_subchannels(),
             subchannel_.get());
   }
-  GPR_ASSERT(pending_watcher_ == nullptr);
-  pending_watcher_ =
-      new Watcher(this, subchannel_list()->WeakRef(DEBUG_LOCATION, "Watcher"));
-  subchannel_->WatchConnectivityState(
-      // NOLINTNEXTLINE(google-readability-casting)
-      std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>(
-          pending_watcher_));
+  GPR_ASSERT(health_watcher_ == nullptr);
+  auto watcher = std::make_unique<Watcher>(
+      this, subchannel_list()->WeakRef(DEBUG_LOCATION, "Watcher"));
+  auto health_watcher = MakeHealthCheckWatcher(
+      subchannel_list_->work_serializer(), args, std::move(watcher));
+  health_watcher_ = health_watcher.get();
+  subchannel_->AddDataWatcher(std::move(health_watcher));
 }
 
 template <typename SubchannelListType, typename SubchannelDataType>
 void SubchannelData<SubchannelListType, SubchannelDataType>::
     CancelConnectivityWatchLocked(const char* reason) {
-  if (pending_watcher_ != nullptr) {
+  if (health_watcher_ != nullptr) {
     if (GPR_UNLIKELY(subchannel_list_->tracer() != nullptr)) {
       gpr_log(GPR_INFO,
               "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
-              " (subchannel %p): canceling connectivity watch (%s)",
+              " (subchannel %p): canceling health watch (%s)",
               subchannel_list_->tracer(), subchannel_list_->policy(),
               subchannel_list_, Index(), subchannel_list_->num_subchannels(),
               subchannel_.get(), reason);
     }
-    subchannel_->CancelConnectivityStateWatch(pending_watcher_);
-    pending_watcher_ = nullptr;
+    subchannel_->CancelDataWatcher(health_watcher_);
+    health_watcher_ = nullptr;
   }
 }
 
@@ -411,10 +414,10 @@ SubchannelList<SubchannelListType, SubchannelDataType>::~SubchannelList() {
 }
 
 template <typename SubchannelListType, typename SubchannelDataType>
-void SubchannelList<SubchannelListType,
-                    SubchannelDataType>::StartWatchingLocked() {
+void SubchannelList<SubchannelListType, SubchannelDataType>::
+    StartWatchingLocked(const ChannelArgs& args) {
   for (auto& sd : subchannels_) {
-    sd->StartConnectivityWatchLocked();
+    sd->StartConnectivityWatchLocked(args);
   }
 }
 

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());