Support slow Start mode in Envoy

api/envoy/config/cluster/v3/cluster.proto

@@ -440,7 +440,7 @@ message Cluster {
   }
 
   // Common configuration for all load balancer implementations.
-  // [#next-free-field: 8]
+  // [#next-free-field: 9]
   message CommonLbConfig {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.Cluster.CommonLbConfig";
@@ -508,6 +508,18 @@ message Cluster {
       google.protobuf.UInt32Value hash_balance_factor = 2 [(validate.rules).uint32 = {gte: 100}];
     }
 
+    enum EndpointWarmingPolicy {
+      NO_WAIT = 0;
+      WAIT_FOR_FIRST_PASSING_HC = 1;
+    }
+
+    // Configuration for slow start mode.
+    // [#next-free-field: 3]
+    message SlowStartConfig {
+      google.protobuf.UInt32Value slow_start_window = 1;
+      EndpointWarmingPolicy endpoint_warming_policy = 2;
+    }
+
     // Configures the :ref:`healthy panic threshold <arch_overview_load_balancing_panic_threshold>`.
     // If not specified, the default is 50%.
     // To disable panic mode, set to 0%.
@@ -565,6 +577,9 @@ message Cluster {
 
     // Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
     ConsistentHashingLbConfig consistent_hashing_lb_config = 7;
+
+    // Configuration for slow start mode.
+    SlowStartConfig slow_start_config = 8;
   }
 
   message RefreshRate {

api/envoy/config/cluster/v4alpha/cluster.proto

@@ -445,8 +445,20 @@ message Cluster {
     bool use_http_header = 1;
   }
 
+  enum EndpointWarmingPolicy {
+    WAIT_FOR_FIRST_PASSING_HC = 0;
+    NO_WAIT = 1;
+  }
+
+  // Configuration for slow start mode.
+  // [#next-free-field: 3]
+  message SlowStartConfig {
+    google.protobuf.UInt32Value slow_start_window = 1;
+    EndpointWarmingPolicy endpoint_warming_policy = 2;
+  }
+
   // Common configuration for all load balancer implementations.
-  // [#next-free-field: 8]
+  // [#next-free-field: 9]
   message CommonLbConfig {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.config.cluster.v3.Cluster.CommonLbConfig";
@@ -571,6 +583,9 @@ message Cluster {
 
     // Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
     ConsistentHashingLbConfig consistent_hashing_lb_config = 7;
+
+    // Configuration for slow start mode.
+    SlowStartConfig slow_start_config = 8;
   }
 
   message RefreshRate {

include/envoy/upstream/host_description.h

@@ -148,6 +148,11 @@ class HostDescription {
    * Set the current priority.
    */
   virtual void priority(uint32_t) PURE;
+
+  /**
+   * @return timestamp in milliseconds of when host was created.
+   */
+  virtual const uint64_t creationTimeMs() const PURE;
 };
 
 using HostDescriptionConstSharedPtr = std::shared_ptr<const HostDescription>;

source/common/upstream/edf_scheduler.h

@@ -73,6 +73,9 @@ template <class C> class EdfScheduler {
    */
   bool empty() const { return queue_.empty(); }
 
+  // todo(nezdolik) this needs to be integer
+  double currentTimeMs() const { return current_time_; }
+
 private:
   struct EdfEntry {
     double deadline_;

source/common/upstream/load_balancer_impl.cc

@@ -66,6 +66,11 @@ bool hostWeightsAreEqual(const HostVector& hosts) {
   return true;
 }
 
+bool noHostsAreInSlowStart() {
+  // todo(nezdolik) fix this
+  return true;
+}
+
 } // namespace
 
 std::pair<uint32_t, LoadBalancerBase::HostAvailability>
@@ -720,10 +725,11 @@ void EdfLoadBalancerBase::refresh(uint32_t priority) {
     auto& scheduler = scheduler_[source] = Scheduler{};
     refreshHostSource(source);
 
-    // Check if the original host weights are equal and skip EDF creation if they are. When all
-    // original weights are equal we can rely on unweighted host pick to do optimal round robin and
-    // least-loaded host selection with lower memory and CPU overhead.
-    if (hostWeightsAreEqual(hosts)) {
+    // Check if the original host weights are equal and no hosts are in slow start mode, in that
+    // case EDF creation is skipped. When all original weights are equal and no hosts are in slow
+    // start mode we can rely on unweighted host pick to do optimal round robin and least-loaded
+    // host selection with lower memory and CPU overhead.
+    if (hostWeightsAreEqual(hosts) && noHostsAreInSlowStart()) {
       // Skip edf creation.
       return;
     }
@@ -736,11 +742,19 @@ void EdfLoadBalancerBase::refresh(uint32_t priority) {
     // We should probably change this to refresh at all times. See the comment in
     // BaseDynamicClusterImpl::updateDynamicHostList about this.
     for (const auto& host : hosts) {
+      auto host_weight = hostWeight(*host);
+      // todo(nezdolik) propagate slow_start_config and endpoint_warming_policy to edf lb base, add
+      // abs to formula
+      if (scheduler.edf_->currentTimeMs() - host->creationTimeMs() > 60) {
+        // todo(nezdolik) parametrize this
+        host_weight *= 0.1;
+      }
+
       // We use a fixed weight here. While the weight may change without
       // notification, this will only be stale until this host is next picked,
       // at which point it is reinserted into the EdfScheduler with its new
       // weight in chooseHost().
-      scheduler.edf_->add(hostWeight(*host), host);
+      scheduler.edf_->add(host_weight, host);
     }
 
     // Cycle through hosts to achieve the intended offset behavior.

source/common/upstream/load_balancer_impl.h

@@ -461,7 +461,16 @@ class LeastRequestLoadBalancer : public EdfLoadBalancerBase,
             least_request_config.has_value() && least_request_config->has_active_request_bias()
                 ? std::make_unique<Runtime::Double>(least_request_config->active_request_bias(),
                                                     runtime)
-                : nullptr) {
+                : nullptr),
+        // todo(nezdolik) move this to base class
+        endpoint_warming_policy(common_config.has_slow_start_config()
+                                    ? common_config.slow_start_config().endpoint_warming_policy()
+                                    : envoy::config::cluster::v3::Cluster::CommonLbConfig::NO_WAIT),
+        // todo(nezdolik) move this to base class
+        slow_start_window(common_config.has_slow_start_config()
+                              ? PROTOBUF_GET_WRAPPED_OR_DEFAULT(common_config.slow_start_config(),
+                                                                slow_start_window, 0)
+                              : 0) {
     initialize();
   }
 
@@ -521,18 +530,27 @@ class LeastRequestLoadBalancer : public EdfLoadBalancerBase,
   double active_request_bias_{};
 
   const std::unique_ptr<Runtime::Double> active_request_bias_runtime_;
+  const envoy::config::cluster::v3::Cluster::CommonLbConfig::EndpointWarmingPolicy
+      endpoint_warming_policy;
+  const uint32_t slow_start_window;
 };
 
 /**
  * Random load balancer that picks a random host out of all hosts.
  */
-class RandomLoadBalancer : public ZoneAwareLoadBalancerBase {
+class RandomLoadBalancer : public ZoneAwareLoadBalancerBase,
+                                 Logger::Loggable<Logger::Id::upstream> {
 public:
   RandomLoadBalancer(const PrioritySet& priority_set, const PrioritySet* local_priority_set,
                      ClusterStats& stats, Runtime::Loader& runtime, Random::RandomGenerator& random,
                      const envoy::config::cluster::v3::Cluster::CommonLbConfig& common_config)
       : ZoneAwareLoadBalancerBase(priority_set, local_priority_set, stats, runtime, random,
-                                  common_config) {}
+                                  common_config) {
+    if (common_config.has_slow_start_config()) {
+      // todo(nezdolik) maybe use error status
+      ENVOY_LOG(warn, "Slow start mode is not supported for random lb");
+    }
+  }
 
   // Upstream::LoadBalancerBase
   HostConstSharedPtr chooseHostOnce(LoadBalancerContext* context) override;

source/common/upstream/logical_host.h

@@ -57,6 +57,10 @@ class LogicalHost : public HostImpl {
     return HostImpl::healthCheckAddress();
   }
 
+  const uint64_t creationTimeMs() const override {
+      return 0;
+  }
+
 private:
   const Network::TransportSocketOptionsSharedPtr override_transport_socket_options_;
   mutable absl::Mutex address_lock_;
@@ -104,6 +108,9 @@ class RealHostDescription : public HostDescription {
     // checking.
     NOT_IMPLEMENTED_GCOVR_EXCL_LINE;
   }
+  const uint64_t creationTimeMs() const override {
+      return 0;
+  }
   uint32_t priority() const override { return logical_host_->priority(); }
   void priority(uint32_t) override { NOT_IMPLEMENTED_GCOVR_EXCL_LINE; }
 

source/common/upstream/maglev_lb.cc

@@ -113,6 +113,9 @@ MaglevLoadBalancer::MaglevLoadBalancer(
   if (!Primes::isPrime(table_size_)) {
     throw EnvoyException("The table size of maglev must be prime number");
   }
+  if (common_config.has_slow_start_config()) {
+    throw EnvoyException("Slow start mode is not supported for maglev lb");
+  }
 }
 
 MaglevLoadBalancerStats MaglevLoadBalancer::generateStats(Stats::Scope& scope) {

source/common/upstream/original_dst_cluster.h

@@ -51,8 +51,15 @@ class OriginalDstCluster : public ClusterImplBase {
    */
   class LoadBalancer : public Upstream::LoadBalancer {
   public:
-    LoadBalancer(const std::shared_ptr<OriginalDstCluster>& parent)
-        : parent_(parent), host_map_(parent->getCurrentHostMap()) {}
+    LoadBalancer(
+        const std::shared_ptr<OriginalDstCluster>&
+            parent /*, const envoy::config::cluster::v3::Cluster::CommonLbConfig& common_config*/)
+        : parent_(parent), host_map_(parent->getCurrentHostMap()) {
+      // todo(nezdolik) fix this
+      //   if (common_config.has_slow_start_config()) {
+      //     throw EnvoyException("Slow start mode is not supported for original dst lb");
+      // }
+    }
 
     // Upstream::LoadBalancer
     HostConstSharedPtr chooseHost(LoadBalancerContext* context) override;

source/common/upstream/ring_hash_lb.cc

@@ -43,6 +43,9 @@ RingHashLoadBalancer::RingHashLoadBalancer(
     throw EnvoyException(fmt::format("ring hash: minimum_ring_size ({}) > maximum_ring_size ({})",
                                      min_ring_size_, max_ring_size_));
   }
+  if (common_config.has_slow_start_config()) {
+    throw EnvoyException("Slow start mode is not supported for ring hash lb");
+  }
 }
 
 RingHashLoadBalancerStats RingHashLoadBalancer::generateStats(Stats::Scope& scope) {

source/common/upstream/subset_lb.cc

@@ -41,6 +41,10 @@ SubsetLoadBalancer::SubsetLoadBalancer(
       scale_locality_weight_(subsets.scaleLocalityWeight()), list_as_any_(subsets.listAsAny()) {
   ASSERT(subsets.isEnabled());
 
+  if (common_config.has_slow_start_config()) {
+    throw EnvoyException("Slow start mode is not supported for subset lb");
+  }
+
   if (fallback_policy_ != envoy::config::cluster::v3::Cluster::LbSubsetConfig::NO_FALLBACK) {
     HostPredicate predicate;
     if (fallback_policy_ == envoy::config::cluster::v3::Cluster::LbSubsetConfig::ANY_ENDPOINT) {

source/common/upstream/upstream_impl.h

@@ -234,6 +234,9 @@ class HostImpl : public HostDescriptionImpl,
   void weight(uint32_t new_weight) override;
   bool used() const override { return used_; }
   void used(bool new_used) override { used_ = new_used; }
+  const uint64_t creationTimeMs() const override {
+      return 0;
+  }
 
 protected:
   static Network::ClientConnectionPtr