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.

Author: wenyihu6

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

@@ -2056,9 +2056,11 @@ 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),
 	}
 }
@@ -2067,9 +2069,11 @@ func (a *Allocator) ScorerOptions(ctx context.Context) *RangeCountScorerOptions
 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
@@ -2518,9 +2522,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...),

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

@@ -342,10 +342,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 +356,46 @@ 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
+// 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 +496,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 +531,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

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,

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

@@ -1310,7 +1310,7 @@ func TestAllocatorRebalanceBasedOnRangeCount(t *testing.T) {
 	gossiputil.NewStoreGossiper(g).GossipStores(stores, t)
 
 	options := a.ScorerOptions(ctx)
-	options.DiskCapacityOptions = testingDiskCapacityOptions
+	options.BaseScorerOptions.DiskCapacity = testingDiskCapacityOptions
 
 	// Every rebalance target must be either store 1 or 2.
 	for i := 0; i < 10; i++ {
@@ -1708,7 +1708,7 @@ func TestAllocatorRebalanceByQPS(t *testing.T) {
 			gossiputil.NewStoreGossiper(g).GossipStores(subtest.testStores, t)
 			var rangeUsageInfo allocator.RangeUsageInfo
 			options := TestingQPSLoadScorerOptions(100, 0.2)
-			options.IOOverloadOptions = IOOverloadOptions{ReplicaEnforcementLevel: IOOverloadThresholdIgnore}
+			options.BaseScorerOptions.IOOverload = IOOverloadOptions{ReplicaEnforcementLevel: IOOverloadThresholdIgnore}
 			add, remove, _, ok := a.RebalanceVoter(
 				ctx,
 				sp,
@@ -1822,7 +1822,7 @@ func TestAllocatorRemoveBasedOnQPS(t *testing.T) {
 		defer stopper.Stop(ctx)
 		gossiputil.NewStoreGossiper(g).GossipStores(subtest.testStores, t)
 		options := TestingQPSLoadScorerOptions(0, 0.1)
-		options.IOOverloadOptions = IOOverloadOptions{ReplicaEnforcementLevel: IOOverloadThresholdIgnore}
+		options.BaseScorerOptions.IOOverload = IOOverloadOptions{ReplicaEnforcementLevel: IOOverloadThresholdIgnore}
 		remove, _, err := a.RemoveVoter(
 			ctx,
 			sp,
@@ -4924,7 +4924,7 @@ func TestAllocatorRebalanceIOOverloadCheck(t *testing.T) {
 			sg.GossipStores(test.stores, t)
 			// Enable read disk health checking in candidate exclusion.
 			options := a.ScorerOptions(ctx)
-			options.IOOverloadOptions = IOOverloadOptions{
+			options.BaseScorerOptions.IOOverload = IOOverloadOptions{
 				ReplicaEnforcementLevel:    test.enforcement,
 				ReplicaIOOverloadThreshold: 1,
 				UseIOThresholdMax:          true,
@@ -9071,7 +9071,7 @@ func qpsBasedRebalanceFn(
 	)
 	if ok {
 		log.Dev.Infof(ctx, "rebalancing from %v to %v; details: %s", remove, add, details)
-		candidate.rebalance(&testStores[int(add.StoreID)], alloc.randGen.Int63n(1<<20), jitteredQPS, opts.DiskOptions)
+		candidate.rebalance(&testStores[int(add.StoreID)], alloc.randGen.Int63n(1<<20), jitteredQPS, opts.BaseScorerOptions.DiskCapacity)
 	}
 }
 
@@ -9476,8 +9476,10 @@ func TestingQPSLoadScorerOptions(
 	qpsPerReplica float64, qpsRebalanceThreshold float64,
 ) *LoadScorerOptions {
 	options := &LoadScorerOptions{
-		DiskOptions:                  defaultDiskCapacityOptions(),
-		Deterministic:                true,
+		BaseScorerOptions: BaseScorerOptions{
+			DiskCapacity:  defaultDiskCapacityOptions(),
+			Deterministic: true,
+		},
 		LoadDims:                     []load.Dimension{load.Queries},
 		LoadThreshold:                MakeQPSOnlyDim(qpsRebalanceThreshold),
 		MinLoadThreshold:             LoadMinThresholds(load.Queries),

pkg/kv/kvserver/asim/storerebalancer/store_rebalancer.go

@@ -132,9 +132,11 @@ func (s simRebalanceObjectiveProvider) Objective() kvserver.LBRebalancingObjecti
 func (src *storeRebalancerControl) scorerOptions() *allocatorimpl.LoadScorerOptions {
 	dim := kvserver.LBRebalancingObjective(src.settings.LBRebalancingObjective).ToDimension()
 	return &allocatorimpl.LoadScorerOptions{
-		IOOverloadOptions:            src.allocator.IOOverloadOptions(),
-		DiskOptions:                  src.allocator.DiskOptions(),
-		Deterministic:                true,
+		BaseScorerOptions: allocatorimpl.BaseScorerOptions{
+			IOOverload:    src.allocator.IOOverloadOptions(),
+			DiskCapacity:  src.allocator.DiskOptions(),
+			Deterministic: true,
+		},
 		LoadDims:                     []load.Dimension{dim},
 		LoadThreshold:                allocatorimpl.LoadThresholds(&src.settings.ST.SV, dim),
 		MinLoadThreshold:             allocatorimpl.LoadMinThresholds(dim),

pkg/kv/kvserver/store_rebalancer.go

@@ -319,9 +319,11 @@ func (sr *StoreRebalancer) scorerOptions(
 	ctx context.Context, lbDimension load.Dimension,
 ) *allocatorimpl.LoadScorerOptions {
 	return &allocatorimpl.LoadScorerOptions{
-		IOOverloadOptions:            sr.allocator.IOOverloadOptions(),
-		DiskOptions:                  sr.allocator.DiskOptions(),
-		Deterministic:                sr.storePool.IsDeterministic(),
+		BaseScorerOptions: allocatorimpl.BaseScorerOptions{
+			IOOverload:    sr.allocator.IOOverloadOptions(),
+			DiskCapacity:  sr.allocator.DiskOptions(),
+			Deterministic: sr.storePool.IsDeterministic(),
+		},
 		LoadDims:                     []load.Dimension{lbDimension},
 		LoadThreshold:                allocatorimpl.LoadThresholds(&sr.st.SV, lbDimension),
 		MinLoadThreshold:             allocatorimpl.LoadMinThresholds(lbDimension),

pkg/kv/kvserver/store_rebalancer_test.go

@@ -932,7 +932,7 @@ func TestChooseRangeToRebalanceRandom(t *testing.T) {
 			hottestRanges := sr.replicaRankings.TopLoad(lbRebalanceDimension)
 			options := sr.scorerOptions(ctx, lbRebalanceDimension)
 			rctx := sr.NewRebalanceContext(ctx, options, hottestRanges, sr.RebalanceMode())
-			rctx.options.IOOverloadOptions = allocatorimpl.IOOverloadOptions{ReplicaEnforcementLevel: allocatorimpl.IOOverloadThresholdIgnore}
+			rctx.options.IOOverload = allocatorimpl.IOOverloadOptions{ReplicaEnforcementLevel: allocatorimpl.IOOverloadThresholdIgnore}
 			rctx.options.LoadThreshold = allocatorimpl.WithAllDims(rebalanceThreshold)
 
 			_, voterTargets, nonVoterTargets := sr.chooseRangeToRebalance(ctx, rctx)
@@ -1273,7 +1273,7 @@ func TestChooseRangeToRebalanceAcrossHeterogeneousZones(t *testing.T) {
 			hottestRanges := sr.replicaRankings.TopLoad(lbRebalanceDimension)
 			options := sr.scorerOptions(ctx, lbRebalanceDimension)
 			rctx := sr.NewRebalanceContext(ctx, options, hottestRanges, kvserverbase.LBRebalancingLeasesAndReplicas)
-			rctx.options.IOOverloadOptions = allocatorimpl.IOOverloadOptions{
+			rctx.options.IOOverload = allocatorimpl.IOOverloadOptions{
 				ReplicaEnforcementLevel: allocatorimpl.IOOverloadThresholdBlockTransfers,
 				UseIOThresholdMax:       true,
 			}
@@ -1363,7 +1363,7 @@ func TestChooseRangeToRebalanceIgnoresRangeOnBestStores(t *testing.T) {
 		hottestRanges := sr.replicaRankings.TopLoad(lbRebalanceDimension)
 		options := sr.scorerOptions(ctx, lbRebalanceDimension)
 		rctx := sr.NewRebalanceContext(ctx, options, hottestRanges, sr.RebalanceMode())
-		rctx.options.IOOverloadOptions = allocatorimpl.IOOverloadOptions{
+		rctx.options.IOOverload = allocatorimpl.IOOverloadOptions{
 			ReplicaEnforcementLevel: allocatorimpl.IOOverloadThresholdIgnore}
 		rctx.options.LoadThreshold = allocatorimpl.WithAllDims(0.05)
 
@@ -1530,7 +1530,7 @@ func TestChooseRangeToRebalanceOffHotNodes(t *testing.T) {
 			hottestRanges := sr.replicaRankings.TopLoad(lbRebalanceDimension)
 			options := sr.scorerOptions(ctx, lbRebalanceDimension)
 			rctx := sr.NewRebalanceContext(ctx, options, hottestRanges, sr.RebalanceMode())
-			rctx.options.IOOverloadOptions = allocatorimpl.IOOverloadOptions{
+			rctx.options.IOOverload = allocatorimpl.IOOverloadOptions{
 				ReplicaEnforcementLevel: allocatorimpl.IOOverloadThresholdIgnore}
 			rctx.options.LoadThreshold = allocatorimpl.WithAllDims(tc.rebalanceThreshold)
 
@@ -1637,7 +1637,7 @@ func TestNoLeaseTransferToBehindReplicas(t *testing.T) {
 		hottestRanges = sr.replicaRankings.TopLoad(lbRebalanceDimension)
 		options = sr.scorerOptions(ctx, lbRebalanceDimension)
 		rctx = sr.NewRebalanceContext(ctx, options, hottestRanges, sr.RebalanceMode())
-		rctx.options.IOOverloadOptions = allocatorimpl.IOOverloadOptions{
+		rctx.options.IOOverload = allocatorimpl.IOOverloadOptions{
 			ReplicaEnforcementLevel: allocatorimpl.IOOverloadThresholdIgnore}
 		rctx.options.LoadThreshold = allocatorimpl.WithAllDims(0.05)
 		rctx.options.Deterministic = true
@@ -1799,7 +1799,7 @@ func TestStoreRebalancerIOOverloadCheck(t *testing.T) {
 			rctx := sr.NewRebalanceContext(ctx, options, hottestRanges, sr.RebalanceMode())
 			require.Greater(t, len(rctx.hottestRanges), 0)
 
-			rctx.options.IOOverloadOptions = allocatorimpl.IOOverloadOptions{
+			rctx.options.IOOverload = allocatorimpl.IOOverloadOptions{
 				ReplicaEnforcementLevel: test.enforcement, ReplicaIOOverloadThreshold: allocatorimpl.DefaultReplicaIOOverloadThreshold}
 			rctx.options.LoadThreshold = allocatorimpl.WithAllDims(0.05)