Introduce Least Request LB active request bias config

source/common/runtime/runtime_features.cc

@@ -81,6 +81,7 @@ constexpr const char* runtime_features[] = {
 constexpr const char* disabled_runtime_features[] = {
     // Sentinel and test flag.
     "envoy.reloadable_features.test_feature_false",
+    "envoy.reloadable_features.alternative_least_request_weights",
 };
 
 RuntimeFeatures::RuntimeFeatures() {

source/common/upstream/BUILD

@@ -181,6 +181,7 @@ envoy_cc_library(
         "//include/envoy/upstream:upstream_interface",
         "//source/common/common:assert_lib",
         "//source/common/protobuf:utility_lib",
+        "//source/common/runtime:runtime_features_lib",
         "@envoy_api//envoy/config/cluster/v3:pkg_cc_proto",
     ],
 )

source/common/upstream/load_balancer_impl.h

@@ -11,6 +11,7 @@
 #include "envoy/upstream/upstream.h"
 
 #include "common/protobuf/utility.h"
+#include "common/runtime/runtime_features.h"
 #include "common/upstream/edf_scheduler.h"
 
 namespace Envoy {
@@ -367,6 +368,8 @@ class EdfLoadBalancerBase : public ZoneAwareLoadBalancerBase {
 
   void initialize();
 
+  virtual void refresh(uint32_t priority);
+
   // Seed to allow us to desynchronize load balancers across a fleet. If we don't
   // do this, multiple Envoys that receive an update at the same time (or even
   // multiple load balancers on the same host) will send requests to
@@ -375,7 +378,6 @@ class EdfLoadBalancerBase : public ZoneAwareLoadBalancerBase {
   const uint64_t seed_;
 
 private:
-  void refresh(uint32_t priority);
   virtual void refreshHostSource(const HostsSource& source) PURE;
   virtual double hostWeight(const Host& host) PURE;
   virtual HostConstSharedPtr unweightedHostPick(const HostVector& hosts_to_use,
@@ -454,9 +456,25 @@ class LeastRequestLoadBalancer : public EdfLoadBalancerBase {
     initialize();
   }
 
+  HostConstSharedPtr chooseHost(LoadBalancerContext* context) override {
+    alternativeWeights_ = Runtime::runtimeFeatureEnabled(
+        "envoy.reloadable_features.alternative_least_request_weights");
+    return EdfLoadBalancerBase::chooseHost(context);
+  }
+
+  void refresh(uint32_t priority) override {
+    alternativeWeights_ = Runtime::runtimeFeatureEnabled(
+        "envoy.reloadable_features.alternative_least_request_weights");
+    EdfLoadBalancerBase::refresh(priority);
+  }
+
 private:
   void refreshHostSource(const HostsSource&) override {}
   double hostWeight(const Host& host) override {
+    if (alternativeWeights_) {
+      return host.weight();
+    }
+
     // Here we scale host weight by the number of active requests at the time we do the pick. We
     // always add 1 to avoid division by 0. It might be possible to do better by picking two hosts
     // off of the schedule, and selecting the one with fewer active requests at the time of
@@ -469,7 +487,9 @@ class LeastRequestLoadBalancer : public EdfLoadBalancerBase {
   }
   HostConstSharedPtr unweightedHostPick(const HostVector& hosts_to_use,
                                         const HostsSource& source) override;
+
   const uint32_t choice_count_;
+  bool alternativeWeights_;
 };
 
 /**

test/common/upstream/BUILD

@@ -189,6 +189,7 @@ envoy_cc_test(
         "//source/common/upstream:upstream_lib",
         "//test/mocks/runtime:runtime_mocks",
         "//test/mocks/upstream:upstream_mocks",
+        "//test/test_common:test_runtime_lib",
         "@envoy_api//envoy/config/cluster/v3:pkg_cc_proto",
     ],
 )

test/common/upstream/load_balancer_impl_test.cc

@@ -13,6 +13,7 @@
 #include "test/common/upstream/utility.h"
 #include "test/mocks/runtime/mocks.h"
 #include "test/mocks/upstream/mocks.h"
+#include "test/test_common/test_runtime.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@@ -1532,6 +1533,30 @@ TEST_P(LeastRequestLoadBalancerTest, WeightImbalance) {
   EXPECT_EQ(hostSet().healthy_hosts_[0], lb_.chooseHost(nullptr));
 }
 
+TEST_P(LeastRequestLoadBalancerTest, WeightImbalanceWithAlternativeWeights) {
+  auto scoped_runtime = std::make_unique<TestScopedRuntime>();
+  Runtime::LoaderSingleton::getExisting()->mergeValues(
+      {{"envoy.reloadable_features.alternative_least_request_weights", "true"}});
+
+  hostSet().healthy_hosts_ = {makeTestHost(info_, "tcp://127.0.0.1:80", 1),
+                              makeTestHost(info_, "tcp://127.0.0.1:81", 2)};
+  stats_.max_host_weight_.set(2UL);
+
+  hostSet().hosts_ = hostSet().healthy_hosts_;
+  hostSet().runCallbacks({}, {}); // Trigger callbacks. The added/removed lists are not relevant.
+
+  EXPECT_CALL(random_, random()).WillRepeatedly(Return(0));
+
+  // We should see 2:1 ratio for hosts[1] to hosts[0], regardless of the active request count.
+  hostSet().healthy_hosts_[1]->stats().rq_active_.set(1);
+  EXPECT_EQ(hostSet().healthy_hosts_[1], lb_.chooseHost(nullptr));
+  EXPECT_EQ(hostSet().healthy_hosts_[0], lb_.chooseHost(nullptr));
+  EXPECT_EQ(hostSet().healthy_hosts_[1], lb_.chooseHost(nullptr));
+  EXPECT_EQ(hostSet().healthy_hosts_[1], lb_.chooseHost(nullptr));
+  EXPECT_EQ(hostSet().healthy_hosts_[0], lb_.chooseHost(nullptr));
+  EXPECT_EQ(hostSet().healthy_hosts_[1], lb_.chooseHost(nullptr));
+}
+
 TEST_P(LeastRequestLoadBalancerTest, WeightImbalanceCallbacks) {
   hostSet().healthy_hosts_ = {makeTestHost(info_, "tcp://127.0.0.1:80", 1),
                               makeTestHost(info_, "tcp://127.0.0.1:81", 2)};