allocator: add BaseScorerOptionsNoConvergence

This commit disables range-count based rebalancing in the replicate queue if
CountBasedRebalanceDisabled is true.

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`).

Author: wenyihu6

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

@@ -2065,6 +2065,18 @@ func (a *Allocator) ScorerOptions(ctx context.Context) *RangeCountScorerOptions
 	}
 }
 
+// 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{

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

@@ -401,6 +401,69 @@ 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

pkg/kv/kvserver/allocator/plan/replicate.go

@@ -167,7 +167,10 @@ func (rp ReplicaPlanner) ShouldPlanChange(
 	voterReplicas := desc.Replicas().VoterDescriptors()
 	nonVoterReplicas := desc.Replicas().NonVoterDescriptors()
 	if !rp.knobs.DisableReplicaRebalancing {
-		scorerOptions := rp.allocator.ScorerOptions(ctx)
+		scorerOptions := allocatorimpl.ScorerOptions(rp.allocator.ScorerOptions(ctx))
+		if rp.allocator.CountBasedRebalanceDisabled() {
+			scorerOptions = rp.allocator.BaseScorerOptionsWithNoConvergence()
+		}
 		rangeUsageInfo := repl.RangeUsageInfo()
 		_, _, _, ok := rp.allocator.RebalanceVoter(
 			ctx,
@@ -790,6 +793,9 @@ func (rp ReplicaPlanner) considerRebalance(
 	if scatter {
 		scorerOpts = rp.allocator.ScorerOptionsForScatter(ctx)
 	}
+	if rp.allocator.CountBasedRebalanceDisabled() {
+		scorerOpts = rp.allocator.BaseScorerOptionsWithNoConvergence()
+	}
 	rangeUsageInfo := repl.RangeUsageInfo()
 	addTarget, removeTarget, details, ok := rp.allocator.RebalanceVoter(
 		ctx,