Introduce Least Request LB active request bias config

source/common/upstream/load_balancer_impl.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cmath>
 #include <cstdint>
 #include <queue>
 #include <set>
@@ -13,9 +14,14 @@
 #include "common/protobuf/utility.h"
 #include "common/upstream/edf_scheduler.h"
 
+#include "absl/strings/string_view.h"
+
 namespace Envoy {
 namespace Upstream {
 
+constexpr absl::string_view RuntimeLeastRequestsActiveRequestsExponent =
+    "upstream.least_requests.active_requests_exponent";
+
 // Priority levels and localities are considered overprovisioned with this factor.
 static constexpr uint32_t kDefaultOverProvisioningFactor = 140;
 
@@ -365,7 +371,9 @@ class EdfLoadBalancerBase : public ZoneAwareLoadBalancerBase {
     std::unique_ptr<EdfScheduler<const Host>> edf_;
   };
 
-  void initialize();
+  virtual 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
@@ -375,7 +383,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,
@@ -437,7 +444,8 @@ class RoundRobinLoadBalancer : public EdfLoadBalancerBase {
  *    The benefit of the Maglev table is at the expense of resolution, memory usage is capped.
  *    Additionally, the Maglev table can be shared amongst all threads.
  */
-class LeastRequestLoadBalancer : public EdfLoadBalancerBase {
+class LeastRequestLoadBalancer : public EdfLoadBalancerBase,
+                                 Logger::Loggable<Logger::Id::upstream> {
 public:
   LeastRequestLoadBalancer(
       const PrioritySet& priority_set, const PrioritySet* local_priority_set, ClusterStats& stats,
@@ -454,6 +462,13 @@ class LeastRequestLoadBalancer : public EdfLoadBalancerBase {
     initialize();
   }
 
+protected:
+  void refresh(uint32_t priority) override {
+    active_requests_exponent_ =
+        runtime_.snapshot().getDouble(RuntimeLeastRequestsActiveRequestsExponent, 1.0);
+    EdfLoadBalancerBase::refresh(priority);
+  }
+
 private:
   void refreshHostSource(const HostsSource&) override {}
   double hostWeight(const Host& host) override {
@@ -465,11 +480,37 @@ class LeastRequestLoadBalancer : public EdfLoadBalancerBase {
     // be the only/best way of doing this. Essentially, it makes weight and active requests equally
     // important. Are they equally important in practice? There is no right answer here and we might
     // want to iterate on this as we gain more experience.
-    return static_cast<double>(host.weight()) / (host.stats().rq_active_.value() + 1);
+
+    // TODO(gkleiman): the final PR will not log anything and will return directly instead of using
+    // a temporary variable.
+    double weight;
+
+    if (active_requests_exponent_ == 0.0) {
+      weight = host.weight();
+    } else if (active_requests_exponent_ == 1.0) {
+      weight = static_cast<double>(host.weight()) / (host.stats().rq_active_.value() + 1);
+    } else {
+      weight = static_cast<double>(host.weight()) /
+               std::pow(host.stats().rq_active_.value() + 1, active_requests_exponent_);
+    }
+
+    ENVOY_LOG(trace, "cluster={} address={} active_requests_exponent={} weight={}",
+              host.cluster().name(), host.address()->asString(), active_requests_exponent_, weight);
+
+    return weight;
   }
   HostConstSharedPtr unweightedHostPick(const HostVector& hosts_to_use,
                                         const HostsSource& source) override;
+
   const uint32_t choice_count_;
+
+  // When hosts have different weights, the host weight is calculated as:
+  //
+  // host_weight = (configured_weight / active_requests^k). k is configured via runtime and its
+  // value is cached to avoid having to do a runtime lookup each time a host weight is generated.
+  //
+  // The cached value is refreshed in `LeastRequestLoadBalancer::refresh(uint32_t priority)`.
+  double active_requests_exponent_;
 };
 
 /**

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, WeightImbalanceWithCustomExponent) {
+  EXPECT_CALL(runtime_.snapshot_,
+              getDouble("upstream.least_requests.active_requests_exponent", 1.0))
+      .WillRepeatedly(Return(0.0));
+
+  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)};