grpc 1.52.0 → 1.53.0.pre2

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CLIENT_STATS_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CLIENT_STATS_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CLIENT_STATS_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CLIENT_STATS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -78,4 +78,4 @@ class GrpcLbClientStats : public RefCounted<GrpcLbClientStats> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CLIENT_STATS_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CLIENT_STATS_H

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H
 #include <grpc/support/port_platform.h>
 
 #include <stdint.h>
@@ -72,4 +72,4 @@ bool GrpcLbResponseParse(const grpc_slice& serialized_response,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H

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

@@ -26,7 +26,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -43,8 +42,8 @@
 
 #include "src/core/ext/filters/client_channel/backend_metric.h"
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
+#include "src/core/ext/filters/client_channel/lb_policy/oob_backend_metric_internal.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
-#include "src/core/ext/filters/client_channel/subchannel_interface_internal.h"
 #include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/debug/trace.h"
@@ -54,7 +53,6 @@
 #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/unique_type_name.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -64,81 +62,8 @@
 
 namespace grpc_core {
 
-namespace {
-
 TraceFlag grpc_orca_client_trace(false, "orca_client");
 
-class OrcaWatcher;
-
-// This producer is registered with a subchannel.  It creates a
-// streaming ORCA call and reports the resulting backend metrics to all
-// registered watchers.
-class OrcaProducer : public Subchannel::DataProducerInterface {
- public:
-  void Start(RefCountedPtr<Subchannel> subchannel);
-
-  void Orphan() override;
-
-  static UniqueTypeName Type() {
-    static UniqueTypeName::Factory kFactory("orca");
-    return kFactory.Create();
-  }
-
-  UniqueTypeName type() const override { return Type(); }
-
-  // Adds and removes watchers.
-  void AddWatcher(OrcaWatcher* watcher);
-  void RemoveWatcher(OrcaWatcher* watcher);
-
- private:
-  class ConnectivityWatcher;
-  class OrcaStreamEventHandler;
-
-  // Returns the minimum requested reporting interval across all watchers.
-  Duration GetMinIntervalLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
-
-  // Starts a new stream if we have a connected subchannel.
-  // Called whenever the reporting interval changes or the subchannel
-  // transitions to state READY.
-  void MaybeStartStreamLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
-
-  // Handles a connectivity state change on the subchannel.
-  void OnConnectivityStateChange(grpc_connectivity_state state);
-
-  // Called to notify watchers of a new backend metric report.
-  void NotifyWatchers(const BackendMetricData& backend_metric_data);
-
-  RefCountedPtr<Subchannel> subchannel_;
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
-  ConnectivityWatcher* connectivity_watcher_;
-  Mutex mu_;
-  std::set<OrcaWatcher*> watchers_ ABSL_GUARDED_BY(mu_);
-  Duration report_interval_ ABSL_GUARDED_BY(mu_) = Duration::Infinity();
-  OrphanablePtr<SubchannelStreamClient> stream_client_ ABSL_GUARDED_BY(mu_);
-};
-
-// This watcher is returned to the LB policy and added to the
-// client channel SubchannelWrapper.
-class OrcaWatcher : public InternalSubchannelDataWatcherInterface {
- public:
-  OrcaWatcher(Duration report_interval,
-              std::unique_ptr<OobBackendMetricWatcher> watcher)
-      : report_interval_(report_interval), watcher_(std::move(watcher)) {}
-  ~OrcaWatcher() override;
-
-  Duration report_interval() const { return report_interval_; }
-  OobBackendMetricWatcher* watcher() const { return watcher_.get(); }
-
-  // When the client channel sees this wrapper, it will pass it the real
-  // subchannel to use.
-  void SetSubchannel(Subchannel* subchannel) override;
-
- private:
-  const Duration report_interval_;
-  std::unique_ptr<OobBackendMetricWatcher> watcher_;
-  RefCountedPtr<OrcaProducer> producer_;
-};
-
 //
 // OrcaProducer::ConnectivityWatcher
 //
@@ -404,8 +329,6 @@ void OrcaWatcher::SetSubchannel(Subchannel* subchannel) {
   producer_->AddWatcher(this);
 }
 
-}  // namespace
-
 std::unique_ptr<SubchannelInterface::DataWatcherInterface>
 MakeOobBackendMetricWatcher(Duration report_interval,
                             std::unique_ptr<OobBackendMetricWatcher> watcher) {

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_H
 
 #include <grpc/support/port_platform.h>
 
@@ -54,4 +54,4 @@ MakeOobBackendMetricWatcher(Duration report_interval,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_H

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

@@ -0,0 +1,117 @@
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_INTERNAL_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_INTERNAL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <set>
+#include <utility>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/impl/connectivity_state.h>
+
+#include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
+#include "src/core/ext/filters/client_channel/lb_policy/oob_backend_metric.h"
+#include "src/core/ext/filters/client_channel/subchannel.h"
+#include "src/core/ext/filters/client_channel/subchannel_interface_internal.h"
+#include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
+#include "src/core/lib/gprpp/orphanable.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/unique_type_name.h"
+
+namespace grpc_core {
+
+class OrcaWatcher;
+
+// This producer is registered with a subchannel.  It creates a
+// streaming ORCA call and reports the resulting backend metrics to all
+// registered watchers.
+class OrcaProducer : public Subchannel::DataProducerInterface {
+ public:
+  void Start(RefCountedPtr<Subchannel> subchannel);
+
+  void Orphan() override;
+
+  static UniqueTypeName Type() {
+    static UniqueTypeName::Factory kFactory("orca");
+    return kFactory.Create();
+  }
+
+  UniqueTypeName type() const override { return Type(); }
+
+  // Adds and removes watchers.
+  void AddWatcher(OrcaWatcher* watcher);
+  void RemoveWatcher(OrcaWatcher* watcher);
+
+ private:
+  class ConnectivityWatcher;
+  class OrcaStreamEventHandler;
+
+  // Returns the minimum requested reporting interval across all watchers.
+  Duration GetMinIntervalLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
+
+  // Starts a new stream if we have a connected subchannel.
+  // Called whenever the reporting interval changes or the subchannel
+  // transitions to state READY.
+  void MaybeStartStreamLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
+
+  // Handles a connectivity state change on the subchannel.
+  void OnConnectivityStateChange(grpc_connectivity_state state);
+
+  // Called to notify watchers of a new backend metric report.
+  void NotifyWatchers(const BackendMetricData& backend_metric_data);
+
+  RefCountedPtr<Subchannel> subchannel_;
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
+  ConnectivityWatcher* connectivity_watcher_;
+  Mutex mu_;
+  std::set<OrcaWatcher*> watchers_ ABSL_GUARDED_BY(mu_);
+  Duration report_interval_ ABSL_GUARDED_BY(mu_) = Duration::Infinity();
+  OrphanablePtr<SubchannelStreamClient> stream_client_ ABSL_GUARDED_BY(mu_);
+};
+
+// This watcher is returned to the LB policy and added to the
+// client channel SubchannelWrapper.
+class OrcaWatcher : public InternalSubchannelDataWatcherInterface {
+ public:
+  OrcaWatcher(Duration report_interval,
+              std::unique_ptr<OobBackendMetricWatcher> watcher)
+      : report_interval_(report_interval), watcher_(std::move(watcher)) {}
+  ~OrcaWatcher() override;
+
+  Duration report_interval() const { return report_interval_; }
+  OobBackendMetricWatcher* watcher() const { return watcher_.get(); }
+
+  // When the client channel sees this wrapper, it will pass it the real
+  // subchannel to use.
+  void SetSubchannel(Subchannel* subchannel) override;
+
+ private:
+  const Duration report_interval_;
+  std::unique_ptr<OobBackendMetricWatcher> watcher_;
+  RefCountedPtr<OrcaProducer> producer_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OOB_BACKEND_METRIC_INTERNAL_H

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OUTLIER_DETECTION_OUTLIER_DETECTION_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OUTLIER_DETECTION_OUTLIER_DETECTION_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OUTLIER_DETECTION_OUTLIER_DETECTION_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OUTLIER_DETECTION_OUTLIER_DETECTION_H
 
 #include <grpc/support/port_platform.h>
 
@@ -91,4 +91,4 @@ struct OutlierDetectionConfig {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OUTLIER_DETECTION_OUTLIER_DETECTION_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_OUTLIER_DETECTION_OUTLIER_DETECTION_H

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H
 
 #include <grpc/support/port_platform.h>
 
@@ -44,4 +44,4 @@ struct RingHashConfig {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H

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

@@ -28,6 +28,7 @@
 
 #include <algorithm>
 #include <deque>
+#include <initializer_list>
 #include <list>
 #include <map>
 #include <memory>

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H
 
 #include <grpc/support/port_platform.h>
 
@@ -450,4 +450,4 @@ bool SubchannelList<SubchannelListType,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H

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

@@ -0,0 +1,128 @@
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/lb_policy/weighted_round_robin/static_stride_scheduler.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <utility>
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/support/log.h>
+
+namespace grpc_core {
+
+namespace {
+constexpr uint16_t kMaxWeight = std::numeric_limits<uint16_t>::max();
+}  // namespace
+
+absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
+    absl::Span<const float> float_weights,
+    absl::AnyInvocable<uint32_t()> next_sequence_func) {
+  if (float_weights.empty()) return absl::nullopt;
+  if (float_weights.size() == 1) return absl::nullopt;
+
+  // TODO(b/190488683): should we normalize negative weights to 0?
+
+  const size_t n = float_weights.size();
+  size_t num_zero_weight_channels = 0;
+  double sum = 0;
+  float max = 0;
+  for (const float weight : float_weights) {
+    sum += weight;
+    max = std::max(max, weight);
+    if (weight == 0) {
+      ++num_zero_weight_channels;
+    }
+  }
+
+  if (num_zero_weight_channels == n) return absl::nullopt;
+
+  // Mean of non-zero weights before scaling to `kMaxWeight`.
+  const double unscaled_mean =
+      sum / static_cast<double>(n - num_zero_weight_channels);
+
+  // 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
+  // be measurable on borg.
+  // 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 uint16_t mean = std::lround(scaling_factor * unscaled_mean);
+
+  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));
+  }
+
+  GPR_ASSERT(weights.size() == float_weights.size());
+  return StaticStrideScheduler{std::move(weights),
+                               std::move(next_sequence_func)};
+}
+
+StaticStrideScheduler::StaticStrideScheduler(
+    std::vector<uint16_t> weights,
+    absl::AnyInvocable<uint32_t()> next_sequence_func)
+    : next_sequence_func_(std::move(next_sequence_func)),
+      weights_(std::move(weights)) {
+  GPR_ASSERT(next_sequence_func_ != nullptr);
+}
+
+size_t StaticStrideScheduler::Pick() const {
+  while (true) {
+    const uint32_t sequence = next_sequence_func_();
+
+    // The sequence number is split in two: the lower %n gives the index of the
+    // backend, and the rest gives the number of times we've iterated through
+    // all backends. `generation` is used to deterministically decide whether
+    // we pick or skip the backend on this iteration, in proportion to the
+    // backend's weight.
+    const uint64_t backend_index = sequence % weights_.size();
+    const uint64_t generation = sequence / weights_.size();
+    const uint64_t weight = weights_[backend_index];
+
+    // We pick a backend `weight` times per `kMaxWeight` generations. The
+    // multiply and modulus ~evenly spread out the picks for a given backend
+    // between different generations. The offset by `backend_index` helps to
+    // reduce the chance of multiple consecutive non-picks: if we have two
+    // consecutive backends with an equal, say, 80% weight of the max, with no
+    // offset we would see 1/5 generations that skipped both.
+    // TODO(b/190488683): add test for offset efficacy.
+    const uint16_t kOffset = kMaxWeight / 2;
+    const uint16_t mod =
+        (weight * generation + backend_index * kOffset) % kMaxWeight;
+
+    if (mod < kMaxWeight - weight) {
+      // Probability of skipping = 1 - mean(weights) / max(weights).
+      // For a typical large-scale service using RR, max task utilization will
+      // be ~100% when mean utilization is ~80%. So ~20% of picks will be
+      // skipped.
+      continue;
+    }
+    return backend_index;
+  }
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,71 @@
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_WEIGHTED_ROUND_ROBIN_STATIC_STRIDE_SCHEDULER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_WEIGHTED_ROUND_ROBIN_STATIC_STRIDE_SCHEDULER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+
+namespace grpc_core {
+
+// StaticStrideScheduler implements a stride scheduler without the ability to
+// add, remove, or modify elements after construction. In exchange, not only is
+// it cheaper to construct and batch-update weights than a traditional dynamic
+// stride scheduler, it can also be used to make concurrent picks without any
+// locking.
+//
+// Construction is O(|weights|).  Picking is O(1) if weights are similar, or
+// O(|weights|) if the mean of the non-zero weights is a small fraction of the
+// max. Stores two bytes per weight.
+class StaticStrideScheduler {
+ public:
+  // Constructs and returns a new StaticStrideScheduler, or nullopt if all
+  // wieghts are zero or |weights| <= 1. All weights must be >=0.
+  // `next_sequence_func` should return a rate monotonically increasing sequence
+  // number, which may wrap. `float_weights` does not need to live beyond the
+  // function. Caller is responsible for ensuring `next_sequence_func` remains
+  // valid for all calls to `Pick()`.
+  static absl::optional<StaticStrideScheduler> Make(
+      absl::Span<const float> float_weights,
+      absl::AnyInvocable<uint32_t()> next_sequence_func);
+
+  // Returns the index of the next pick. May invoke `next_sequence_func`
+  // multiple times. The returned value is guaranteed to be in [0, |weights|).
+  // Can be called concurrently iff `next_sequence_func` can.
+  size_t Pick() const;
+
+ private:
+  StaticStrideScheduler(std::vector<uint16_t> weights,
+                        absl::AnyInvocable<uint32_t()> next_sequence_func);
+
+  mutable absl::AnyInvocable<uint32_t()> next_sequence_func_;
+
+  // List of backend weights scaled such that the max(weights_) == kMaxWeight.
+  std::vector<uint16_t> weights_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_WEIGHTED_ROUND_ROBIN_STATIC_STRIDE_SCHEDULER_H