Merge #153220

153220: kvserverbase: add DisableCountBasedRebalancingIfMMAEnabled r=tbg a=wenyihu6

Resolves: #152579
Release note: none

---
**kvserverbase: add DisableCountBasedRebalancingIfMMAEnabled**

This commit introduces a new cluster setting,
`DisableCountBasedRebalancingIfMMAEnabled`, which allows us to disable range-count
and lease-count based convergence rebalancing when mma is enabled. These forms
of rebalancing can conflict with mma goals and cause thrashing.

---
**allocator: add option to disable lease-count based rebalancing**

This commit disables lease-count based rebalancing in the lease queue.

Currently, the lease queue uses `ShouldTransferLease` and `PlanOneChange` to select
a target store for transferring a range lease. Candidate stores are chosen based
on store health, lease preferences, lagging replicas, and I/O load, and the
final target is decided using one of: `FollowTheWorkload`, `LeaseCountConvergence`,
or `LoadConvergence`.

`LeaseCountConvergence` is used in two scenarios:
(1) When `FollowTheWorkload` (`shouldTransferLeaseForAccessLocality`) lacks sufficient
  stats or locality info.
(2) `maybeTransferLeaseAwayTarget`: calls into `allocator.TransferLeaseTarget` with
  `LeaseCountConvergence` directly.

This commit disables case (1) by returning early in
`shouldTransferLeaseForLeaseCountConvergence` (used in
`Allocator.TransferLeaseTarget` and `allocator.ShouldTransferLease`). Case (2) is
left intact, since it is less common and less likely to interfere with MMA
decisions.

---
**kvserver: add `BaseScorerOptions`**

This commit introduces `BaseScorerOptions`, a base struct embedded by other
`ScorerOptions` implementations. It provides the default implementation methods,
while specific implementations can override individual methods to apply their
own scoring heuristics.

---
**allocator: add `adjustRangeCountForScoring`**

This commit adds `adjustRangeCountForScoring` to the `ScorerOptions` interface. The
method takes a provided range count, adjusts it according to the scorer’s
heuristic, and returns the result. It is similar to other scoring metrics such
as the convergence score, and will later be used in candidate.compare as an
attribute for breaking ties. The compare method evaluates the relative
difference between two stores and favors the one with fewer ranges as a better
rebalance target. Currently and by default, `adjustRangeCountForScoring` simply
returns the provided range count. Future scorer options will override it with 0
since the heuristics is to not consider range count at all.

---
**allocator: add `BaseScorerOptionsNoConvergence`**

This commit disables range-count based rebalancing.

Currently, when selecting a rebalance target, the allocator constructs an
equivalence class for each existing replica. This class includes all stores that
are not worse than the existing replica in terms of constraint conformance,
diversity score, and disk fullness. At this stage, range count convergence is
not yet considered. The allocator then evaluates each candidate set using
`ScorerOptions`, which populates candidates' attributes such as balance score,
convergence score, and range count with respect to the equivalence class, and
determines the best candidate within each equivalence class.

To disable range count–based rebalancing, this commit introduces a new scorer
option, `BaseScorerOptionsNoConvergence`. This scorer assigns the same score to
all stores, effectively treating candidates within the same equivalence class
the same. It is only used when both MMA and
`DisableCountBasedRebalancingIfMMAEnabled` are enabled.

Note that this new scorer option is applied only in
`ReplicaPlanner.considerRebalance` and `ReplicaPlanner.ShouldPlanChange`. As a
result, range-count based rebalancing is disabled during rebalancing, but range
count is still considered when allocator adds new replicas (such as
`AllocateVoter`), choosing a rebalance target in the old store rebalancer
(`StoreRebalancer.applyRangeRebalance`), and when removing replicas
(`Allocator.RemoveVoter`).

---
**kvserver: add LBRebalancingMultiMetricAndCount**

This commit removes the cluster setting
DisableCountBasedRebalancingIfMMAEnabled, renames LBRebalancingMultiMetric to
LBRebalancingMultiMetricOnly, and introduces a new mode:
LBRebalancingMultiMetricAndCount. To keep the datadriven test output unchanged,
all previous references to mma in asim now use LBRebalancingMultiMetricAndCount,
which matches the prior behavior. I’ll follow up with a new asim mode in future
commits.




Co-authored-by: wenyihu6 <[email protected]>

Author: craig[bot]

docs/generated/settings/settings.html

@@ -86,7 +86,7 @@
 <tr><td><div id="setting-jobs-retention-time" class="anchored"><code>jobs.retention_time</code></div></td><td>duration</td><td><code>336h0m0s</code></td><td>the amount of time for which records for completed jobs are retained</td><td>Basic/Standard/Advanced/Self-Hosted</td></tr>
 <tr><td><div id="setting-kv-allocator-lease-rebalance-threshold" class="anchored"><code>kv.allocator.lease_rebalance_threshold</code></div></td><td>float</td><td><code>0.05</code></td><td>minimum fraction away from the mean a store&#39;s lease count can be before it is considered for lease-transfers</td><td>Advanced/Self-Hosted</td></tr>
 <tr><td><div id="setting-kv-allocator-load-based-lease-rebalancing-enabled" class="anchored"><code>kv.allocator.load_based_lease_rebalancing.enabled</code></div></td><td>boolean</td><td><code>true</code></td><td>set to enable rebalancing of range leases based on load and latency</td><td>Advanced/Self-Hosted</td></tr>
-<tr><td><div id="setting-kv-allocator-load-based-rebalancing" class="anchored"><code>kv.allocator.load_based_rebalancing</code></div></td><td>enumeration</td><td><code>leases and replicas</code></td><td>whether to rebalance based on the distribution of load across stores [off = 0, leases = 1, leases and replicas = 2, multi-metric = 3]</td><td>Advanced/Self-Hosted</td></tr>
+<tr><td><div id="setting-kv-allocator-load-based-rebalancing" class="anchored"><code>kv.allocator.load_based_rebalancing</code></div></td><td>enumeration</td><td><code>leases and replicas</code></td><td>whether to rebalance based on the distribution of load across stores [off = 0, leases = 1, leases and replicas = 2, multi-metric = 3, multi-metric and count = 4]</td><td>Advanced/Self-Hosted</td></tr>
 <tr><td><div id="setting-kv-allocator-load-based-rebalancing-objective" class="anchored"><code>kv.allocator.load_based_rebalancing.objective</code></div></td><td>enumeration</td><td><code>cpu</code></td><td>what objective does the cluster use to rebalance; if set to `qps` the cluster will attempt to balance qps among stores, if set to `cpu` the cluster will attempt to balance cpu usage among stores [qps = 0, cpu = 1]</td><td>Advanced/Self-Hosted</td></tr>
 <tr><td><div id="setting-kv-allocator-load-based-rebalancing-interval" class="anchored"><code>kv.allocator.load_based_rebalancing_interval</code></div></td><td>duration</td><td><code>1m0s</code></td><td>the rough interval at which each store will check for load-based lease / replica rebalancing opportunities</td><td>Advanced/Self-Hosted</td></tr>
 <tr><td><div id="setting-kv-allocator-qps-rebalance-threshold" class="anchored"><code>kv.allocator.qps_rebalance_threshold</code></div></td><td>float</td><td><code>0.1</code></td><td>minimum fraction away from the mean a store&#39;s QPS (such as queries per second) can be before it is considered overfull or underfull</td><td>Advanced/Self-Hosted</td></tr>

pkg/kv/kvserver/allocator/allocatorimpl/BUILD.bazel

@@ -18,6 +18,7 @@ go_library(
         "//pkg/kv/kvserver/allocator/storepool",
         "//pkg/kv/kvserver/constraint",
         "//pkg/kv/kvserver/kvflowcontrol/rac2",
+        "//pkg/kv/kvserver/kvserverbase",
         "//pkg/kv/kvserver/liveness",
         "//pkg/kv/kvserver/liveness/livenesspb",
         "//pkg/kv/kvserver/raftutil",

pkg/kv/kvserver/allocator/allocatorimpl/allocator.go

@@ -20,6 +20,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/allocator/storepool"
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/constraint"
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/kvflowcontrol/rac2"
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/kvserverbase"
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/raftutil"
 	"github.com/cockroachdb/cockroach/pkg/raft"
 	"github.com/cockroachdb/cockroach/pkg/raft/raftpb"
@@ -2055,20 +2056,36 @@ func (a Allocator) RebalanceNonVoter(
 // machinery to achieve range count convergence.
 func (a *Allocator) ScorerOptions(ctx context.Context) *RangeCountScorerOptions {
 	return &RangeCountScorerOptions{
-		IOOverloadOptions:       a.IOOverloadOptions(),
-		DiskCapacityOptions:     a.DiskOptions(),
-		deterministic:           a.deterministic,
+		BaseScorerOptions: BaseScorerOptions{
+			IOOverload:    a.IOOverloadOptions(),
+			DiskCapacity:  a.DiskOptions(),
+			Deterministic: a.deterministic,
+		},
 		rangeRebalanceThreshold: RangeRebalanceThreshold.Get(&a.st.SV),
 	}
 }
 
+// BaseScorerOptionsWithNoConvergence returns the base scorer options with no
+// convergence heuristics.
+func (a *Allocator) BaseScorerOptionsWithNoConvergence() BaseScorerOptionsNoConvergence {
+	return BaseScorerOptionsNoConvergence{
+		BaseScorerOptions: BaseScorerOptions{
+			IOOverload:    a.IOOverloadOptions(),
+			DiskCapacity:  a.DiskOptions(),
+			Deterministic: a.deterministic,
+		},
+	}
+}
+
 // ScorerOptionsForScatter returns the scorer options for scattering purposes.
 func (a *Allocator) ScorerOptionsForScatter(ctx context.Context) *ScatterScorerOptions {
 	return &ScatterScorerOptions{
 		RangeCountScorerOptions: RangeCountScorerOptions{
-			IOOverloadOptions:       a.IOOverloadOptions(),
-			DiskCapacityOptions:     a.DiskOptions(),
-			deterministic:           a.deterministic,
+			BaseScorerOptions: BaseScorerOptions{
+				IOOverload:    a.IOOverloadOptions(),
+				DiskCapacity:  a.DiskOptions(),
+				Deterministic: a.deterministic,
+			},
 			rangeRebalanceThreshold: 0,
 		},
 		// We set jitter to be equal to the padding around replica-count rebalancing
@@ -2517,9 +2534,11 @@ func (a *Allocator) TransferLeaseTarget(
 			candidates,
 			storeDescMap,
 			&LoadScorerOptions{
-				IOOverloadOptions:            a.IOOverloadOptions(),
-				DiskOptions:                  a.DiskOptions(),
-				Deterministic:                a.deterministic,
+				BaseScorerOptions: BaseScorerOptions{
+					IOOverload:    a.IOOverloadOptions(),
+					DiskCapacity:  a.DiskOptions(),
+					Deterministic: a.deterministic,
+				},
 				LoadDims:                     opts.LoadDimensions,
 				LoadThreshold:                LoadThresholds(&a.st.SV, opts.LoadDimensions...),
 				MinLoadThreshold:             LoadMinThresholds(opts.LoadDimensions...),
@@ -2725,6 +2744,14 @@ func (t TransferLeaseDecision) String() string {
 	}
 }
 
+// CountBasedRebalancingDisabled returns true if count-based rebalancing should
+// be disabled. Count-based rebalancing is disabled only when
+// LBRebalancingMultiMetricOnly mode is active. To enable both multi-metric and
+// count-based rebalancing, use LBRebalancingMultiMetricAndCount mode instead.
+func (a *Allocator) CountBasedRebalancingDisabled() bool {
+	return kvserverbase.LoadBasedRebalancingMode.Get(&a.st.SV) == kvserverbase.LBRebalancingMultiMetricOnly
+}
+
 // ShouldTransferLease returns true if the specified store is overfull in terms
 // of leases with respect to the other stores matching the specified
 // attributes.
@@ -3024,6 +3051,10 @@ func (a Allocator) shouldTransferLeaseForLeaseCountConvergence(
 	source roachpb.StoreDescriptor,
 	existing []roachpb.ReplicaDescriptor,
 ) bool {
+	// Return false early if count based rebalancing is disabled.
+	if a.CountBasedRebalancingDisabled() {
+		return false
+	}
 	// TODO(a-robinson): Should we disable this behavior when load-based lease
 	// rebalancing is enabled? In happy cases it's nice to keep this working
 	// to even out the number of leases in addition to the number of replicas,

pkg/kv/kvserver/allocator/allocatorimpl/allocator_scorer.go

@@ -292,6 +292,15 @@ type ScorerOptions interface {
 	// the store represented by `sc` classifies as underfull, aroundTheMean, or
 	// overfull relative to all the stores in `sl`.
 	balanceScore(sl storepool.StoreList, sc roachpb.StoreCapacity) balanceStatus
+	// adjustRangeCountForScoring returns the adjusted range count for scoring.
+	// Scorer options (IOOverloadOnlyScorerOptions) that do not score based on
+	// range count convergence returns 0. Otherwise, the returned range count here
+	// should usually be the same as the range count passed in
+	// (RangeCountScorerOptions, LoadScorerOptions, ScatterScorerOptions). This
+	// will later be used to calculate the relative difference when comparing the
+	// range count of the candidate stores. Lower range count means a better
+	// candidate to move the replica to.
+	adjustRangeCountForScoring(rangeCount int) int
 	// rebalanceFromConvergenceScore assigns a convergence score to the store
 	// referred to by `eqClass.existing` based on whether moving a replica away
 	// from this store would converge its stats towards the mean (relative to the
@@ -342,10 +351,6 @@ type ScatterScorerOptions struct {
 
 var _ ScorerOptions = &ScatterScorerOptions{}
 
-func (o *ScatterScorerOptions) getIOOverloadOptions() IOOverloadOptions {
-	return o.RangeCountScorerOptions.IOOverloadOptions
-}
-
 func (o *ScatterScorerOptions) maybeJitterStoreStats(
 	sl storepool.StoreList, allocRand allocatorRand,
 ) (perturbedSL storepool.StoreList) {
@@ -360,37 +365,116 @@ func (o *ScatterScorerOptions) maybeJitterStoreStats(
 	return storepool.MakeStoreList(perturbedStoreDescs)
 }
 
-// RangeCountScorerOptions is used by the replicateQueue to tell the Allocator's
-// rebalancing machinery to base its balance/convergence scores on range counts.
-// This means that the resulting rebalancing decisions will further the goal of
-// converging range counts across stores in the cluster.
-type RangeCountScorerOptions struct {
-	IOOverloadOptions
-	DiskCapacityOptions
-	deterministic           bool
-	rangeRebalanceThreshold float64
+// BaseScorerOptions is the base scorer options that is embedded in
+// every scorer option.
+type BaseScorerOptions struct {
+	IOOverload    IOOverloadOptions
+	DiskCapacity  DiskCapacityOptions
+	Deterministic bool
 }
 
-var _ ScorerOptions = &RangeCountScorerOptions{}
+func (bo BaseScorerOptions) getIOOverloadOptions() IOOverloadOptions {
+	return bo.IOOverload
+}
 
-func (o *RangeCountScorerOptions) getIOOverloadOptions() IOOverloadOptions {
-	return o.IOOverloadOptions
+func (bo BaseScorerOptions) getDiskOptions() DiskCapacityOptions {
+	return bo.DiskCapacity
 }
 
-func (o *RangeCountScorerOptions) getDiskOptions() DiskCapacityOptions {
-	return o.DiskCapacityOptions
+func (bo BaseScorerOptions) deterministicForTesting() bool {
+	return bo.Deterministic
 }
 
-func (o *RangeCountScorerOptions) maybeJitterStoreStats(
+// maybeJitterStoreStats returns the provided store list since that is the
+// default behavior. ScatterScorerOptions is the only scorer option that jitters
+// store stats to rebalance replicas across stores randomly.
+func (bo BaseScorerOptions) maybeJitterStoreStats(
 	sl storepool.StoreList, _ allocatorRand,
-) (perturbedSL storepool.StoreList) {
+) storepool.StoreList {
 	return sl
 }
 
-func (o *RangeCountScorerOptions) deterministicForTesting() bool {
-	return o.deterministic
+// adjustRangeCountForScoring returns the provided range count since that is the
+// default behavior. BaseScorerOptionsNoConvergence is the only scorer option
+// that does not want to consider range count in its scoring, so it returns 0.
+func (bo BaseScorerOptions) adjustRangeCountForScoring(rangeCount int) int {
+	return rangeCount
+}
+
+// BaseScorerOptionsNoConvergence is the base scorer options that does not
+// involve any heuristics or convergence scoring.
+//
+// It assigns the same score to all stores, effectively treating candidates
+// within the same equivalence class the same and disabling range-count based
+// convergence rebalancing.
+//
+// Note that this new scorer option is applied used in
+// ReplicaPlanner.considerRebalance and ReplicaPlanner.ShouldPlanChange. As a
+// result, range-count based rebalancing is disabled during rebalancing, but
+// range count is still considered when allocator adds new replicas (such as
+// AllocateVoter), choosing a rebalance target in the old store rebalancer
+// (StoreRebalancer.applyRangeRebalance), and when removing replicas
+// (Allocator.RemoveVoter).
+type BaseScorerOptionsNoConvergence struct {
+	BaseScorerOptions
+}
+
+var _ ScorerOptions = BaseScorerOptionsNoConvergence{}
+
+// adjustRangeCountForScoring returns 0 since BaseScorerOptionsNoConvergence
+// does not want to consider range count in its scoring.
+func (bnc BaseScorerOptionsNoConvergence) adjustRangeCountForScoring(_ int) int {
+	return 0
+}
+
+// shouldRebalanceBasedOnThresholds returns false since
+// BaseScorerOptionsNoConvergence does not involve any heuristics that evaluate
+// stores within an equivalence class. If no rebalancing is needed based on
+// other attributes (e.g. valid, disk fullness, constraints, diversity score),
+// no rebalancing is done.
+func (bnc BaseScorerOptionsNoConvergence) shouldRebalanceBasedOnThresholds(
+	_ context.Context, _ equivalenceClass, _ AllocatorMetrics,
+) bool {
+	return false
+}
+
+// balanceScore returns aroundTheMean for every store so that
+// BaseScorerOptionsNoConvergence does not take range count into account.
+func (bnc BaseScorerOptionsNoConvergence) balanceScore(
+	_ storepool.StoreList, _ roachpb.StoreCapacity,
+) balanceStatus {
+	return aroundTheMean
+}
+
+// Note that the following three methods all return 0 for every store so that
+// BaseScorerOptionsNoConvergence does not take convergence score into account.
+// Important to keep them the same value since betterRebalanceTarget may compare
+// convergence score the difference between rebalanceFrom and rebalanceTo stores.
+func (bnc BaseScorerOptionsNoConvergence) rebalanceFromConvergesScore(_ equivalenceClass) int {
+	return 0
+}
+func (bnc BaseScorerOptionsNoConvergence) rebalanceToConvergesScore(
+	_ equivalenceClass, _ roachpb.StoreDescriptor,
+) int {
+	return 0
+}
+func (bnc BaseScorerOptionsNoConvergence) removalMaximallyConvergesScore(
+	_ storepool.StoreList, _ roachpb.StoreDescriptor,
+) int {
+	return 0
 }
 
+// RangeCountScorerOptions is used by the replicateQueue to tell the Allocator's
+// rebalancing machinery to base its balance/convergence scores on range counts.
+// This means that the resulting rebalancing decisions will further the goal of
+// converging range counts across stores in the cluster.
+type RangeCountScorerOptions struct {
+	BaseScorerOptions
+	rangeRebalanceThreshold float64
+}
+
+var _ ScorerOptions = &RangeCountScorerOptions{}
+
 func (o RangeCountScorerOptions) shouldRebalanceBasedOnThresholds(
 	ctx context.Context, eqClass equivalenceClass, metrics AllocatorMetrics,
 ) bool {
@@ -491,10 +575,8 @@ func (o *RangeCountScorerOptions) removalMaximallyConvergesScore(
 // queries-per-second. This means that the resulting rebalancing decisions will
 // further the goal of converging QPS across stores in the cluster.
 type LoadScorerOptions struct {
-	IOOverloadOptions IOOverloadOptions
-	DiskOptions       DiskCapacityOptions
-	Deterministic     bool
-	LoadDims          []load.Dimension
+	BaseScorerOptions
+	LoadDims []load.Dimension
 
 	// LoadThreshold and MinLoadThreshold track the threshold beyond which a
 	// store should be considered under/overfull and the minimum absolute
@@ -528,23 +610,7 @@ type LoadScorerOptions struct {
 	RebalanceImpact load.Load
 }
 
-func (o *LoadScorerOptions) getIOOverloadOptions() IOOverloadOptions {
-	return o.IOOverloadOptions
-}
-
-func (o *LoadScorerOptions) getDiskOptions() DiskCapacityOptions {
-	return o.DiskOptions
-}
-
-func (o *LoadScorerOptions) maybeJitterStoreStats(
-	sl storepool.StoreList, _ allocatorRand,
-) storepool.StoreList {
-	return sl
-}
-
-func (o *LoadScorerOptions) deterministicForTesting() bool {
-	return o.Deterministic
-}
+var _ ScorerOptions = &LoadScorerOptions{}
 
 // shouldRebalanceBasedOnThresholds tries to determine if, within the given
 // equivalenceClass `eqClass`, rebalancing a replica from one of the existing
@@ -1168,14 +1234,15 @@ func rankedCandidateListForAllocation(
 			}
 			hasNonVoter = StoreHasReplica(s.StoreID, nonVoterReplTargets)
 		}
+		rangeCountScore := options.adjustRangeCountForScoring(int(s.Capacity.RangeCount))
 		candidates = append(candidates, candidate{
 			store:          s,
 			necessary:      necessary,
 			valid:          constraintsOK,
 			diversityScore: diversityScore,
 			balanceScore:   balanceScore,
 			hasNonVoter:    hasNonVoter,
-			rangeCount:     int(s.Capacity.RangeCount),
+			rangeCount:     rangeCountScore,
 		})
 	}
 	if options.deterministicForTesting() {
@@ -1283,7 +1350,7 @@ func candidateListForRemoval(
 		candidates[i].balanceScore = options.balanceScore(
 			removalCandidateStoreList, candidates[i].store.Capacity,
 		)
-		candidates[i].rangeCount = int(candidates[i].store.Capacity.RangeCount)
+		candidates[i].rangeCount = options.adjustRangeCountForScoring(int(candidates[i].store.Capacity.RangeCount))
 	}
 	// Re-sort to account for the ordering changes resulting from the addition of
 	// convergesScore, balanceScore, etc.
@@ -1748,7 +1815,7 @@ func rankedCandidateListForRebalancing(
 			balanceScore := options.balanceScore(comparable.candidateSL, existing.store.Capacity)
 			existing.convergesScore = convergesScore
 			existing.balanceScore = balanceScore
-			existing.rangeCount = int(existing.store.Capacity.RangeCount)
+			existing.rangeCount = options.adjustRangeCountForScoring(int(existing.store.Capacity.RangeCount))
 		}
 
 		var candidates candidateList
@@ -1774,7 +1841,7 @@ func rankedCandidateListForRebalancing(
 			)
 			cand.balanceScore = options.balanceScore(comparable.candidateSL, s.Capacity)
 			cand.convergesScore = options.rebalanceToConvergesScore(comparable, s)
-			cand.rangeCount = int(s.Capacity.RangeCount)
+			cand.rangeCount = options.adjustRangeCountForScoring(int(s.Capacity.RangeCount))
 			candidates = append(candidates, cand)
 		}
 

pkg/kv/kvserver/allocator/allocatorimpl/allocator_scorer_test.go

@@ -1557,7 +1557,9 @@ func TestShouldRebalanceDiversity(t *testing.T) {
 	defer log.Scope(t).Close(t)
 
 	options := &RangeCountScorerOptions{
-		DiskCapacityOptions: defaultDiskCapacityOptions(),
+		BaseScorerOptions: BaseScorerOptions{
+			DiskCapacity: defaultDiskCapacityOptions(),
+		},
 	}
 	newStore := func(id int, locality roachpb.Locality) roachpb.StoreDescriptor {
 		return roachpb.StoreDescriptor{
@@ -2008,7 +2010,9 @@ func TestBalanceScoreByRangeCount(t *testing.T) {
 	defer log.Scope(t).Close(t)
 
 	options := RangeCountScorerOptions{
-		DiskCapacityOptions:     defaultDiskCapacityOptions(),
+		BaseScorerOptions: BaseScorerOptions{
+			DiskCapacity: defaultDiskCapacityOptions(),
+		},
 		rangeRebalanceThreshold: 0.1,
 	}
 	storeList := storepool.StoreList{
@@ -2094,7 +2098,9 @@ func TestRebalanceConvergesRangeCountOnMean(t *testing.T) {
 	}
 
 	options := RangeCountScorerOptions{
-		DiskCapacityOptions: defaultDiskCapacityOptions(),
+		BaseScorerOptions: BaseScorerOptions{
+			DiskCapacity: defaultDiskCapacityOptions(),
+		},
 	}
 	eqClass := equivalenceClass{
 		candidateSL: storeList,