update

Signed-off-by: lhy1024 <[email protected]>

server/schedulers/hot_region.go

@@ -476,21 +476,32 @@ func (bs *balanceSolver) isValid() bool {
 	return true
 }
 
+func (bs *balanceSolver) filterUniformStore() (string, bool) {
+	// Because region is available for src and dst, so stddev is the same for both, only need to calcurate one.
+	isUniformFirstPriority, isUniformSecondPriority := bs.isUniformFirstPriority(bs.cur.srcStore), bs.isUniformSecondPriority(bs.cur.srcStore)
+	if isUniformFirstPriority && isUniformSecondPriority {
+		// If both dims are enough uniform, any schedule is unnecessary.
+		return "all-dim", true
+	}
+	if isUniformFirstPriority && (bs.cur.progressiveRank == -1 || bs.cur.progressiveRank == -3) {
+		// If first priority dim is enough uniform, -1 is unnecessary and maybe lead to worse balance for second priority dim
+		return dimToString(bs.firstPriority), true
+	}
+	if isUniformSecondPriority && bs.cur.progressiveRank == -2 {
+		// If second priority dim is enough uniform, -2 is unnecessary and maybe lead to worse balance for first priority dim
+		return dimToString(bs.secondPriority), true
+	}
+	return "", false
+}
+
 // solve travels all the src stores, hot peers, dst stores and select each one of them to make a best scheduling solution.
 // The comparing between solutions is based on calcProgressiveRank.
 func (bs *balanceSolver) solve() []*operator.Operator {
 	if !bs.isValid() {
 		return nil
 	}
 	bs.cur = &solution{}
-
-	tryUpdateBestSolution := func(isUniformFirstPriority bool) {
-		if bs.cur.progressiveRank == -1 && isUniformFirstPriority {
-			// Because region is available for src and dst, so stddev is the same for both, only need to calcurate one.
-			// If first priority dim is enough uniform, -1 is unnecessary and maybe lead to worse balance for second priority dim
-			hotSchedulerResultCounter.WithLabelValues("skip-uniform-store", strconv.FormatUint(bs.cur.dstStore.GetID(), 10)).Inc()
-			return
-		}
+	tryUpdateBestSolution := func() {
 		if bs.cur.progressiveRank < 0 && bs.betterThan(bs.best) {
 			if newOps, newInfl := bs.buildOperators(); len(newOps) > 0 {
 				bs.ops = newOps
@@ -504,11 +515,6 @@ func (bs *balanceSolver) solve() []*operator.Operator {
 	for _, srcStore := range bs.filterSrcStores() {
 		bs.cur.srcStore = srcStore
 		srcStoreID := srcStore.GetID()
-		isUniformFirstPriority, isUniformSecondPriority := bs.isUniformFirstPriority(bs.cur.srcStore), bs.isUniformSecondPriority(bs.cur.srcStore)
-		if isUniformFirstPriority && isUniformSecondPriority {
-			hotSchedulerResultCounter.WithLabelValues("skip-uniform-store", strconv.FormatUint(bs.cur.srcStore.GetID(), 10)).Inc()
-			continue
-		}
 		for _, srcPeerStat := range bs.filterHotPeers(srcStore) {
 			if bs.cur.region = bs.getRegion(srcPeerStat, srcStoreID); bs.cur.region == nil {
 				continue
@@ -521,7 +527,11 @@ func (bs *balanceSolver) solve() []*operator.Operator {
 			for _, dstStore := range bs.filterDstStores() {
 				bs.cur.dstStore = dstStore
 				bs.calcProgressiveRank()
-				tryUpdateBestSolution(isUniformFirstPriority)
+				if label, ok := bs.filterUniformStore(); ok {
+					schedulerCounter.WithLabelValues(bs.sche.GetName(), fmt.Sprintf("skip-%s-uniform-store", label)).Inc()
+					continue
+				}
+				tryUpdateBestSolution()
 			}
 		}
 	}

server/schedulers/hot_region_config.go

@@ -221,6 +221,12 @@ func (conf *hotRegionSchedulerConfig) GetGreatDecRatio() float64 {
 	return conf.GreatDecRatio
 }
 
+func (conf *hotRegionSchedulerConfig) SetGreatDecRatio(r float64) {
+	conf.RLock()
+	defer conf.RUnlock()
+	conf.GreatDecRatio = r
+}
+
 func (conf *hotRegionSchedulerConfig) GetMinorDecRatio() float64 {
 	conf.RLock()
 	defer conf.RUnlock()

server/schedulers/hot_region_test.go

@@ -1279,6 +1279,43 @@ func TestHotReadRegionScheduleWithPendingInfluence(t *testing.T) {
 	}
 }
 
+func TestSkipUniformStore(t *testing.T) {
+	re := require.New(t)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	statistics.Denoising = false
+	opt := config.NewTestOptions()
+	hb, err := schedule.CreateScheduler(statistics.Read.String(), schedule.NewOperatorController(ctx, nil, nil), storage.NewStorageWithMemoryBackend(), nil)
+	re.NoError(err)
+	hb.(*hotScheduler).conf.SetSrcToleranceRatio(1)
+	hb.(*hotScheduler).conf.SetDstToleranceRatio(1)
+	hb.(*hotScheduler).conf.SetGreatDecRatio(1.1) //avoid similar store but cannot schedule
+	hb.(*hotScheduler).conf.ReadPriorities = []string{BytePriority, KeyPriority}
+
+	tc := mockcluster.NewCluster(ctx, opt)
+	tc.SetHotRegionCacheHitsThreshold(0)
+	tc.AddRegionStore(1, 20)
+	tc.AddRegionStore(2, 20)
+	tc.AddRegionStore(3, 20)
+	tc.AddRegionStore(4, 20)
+	tc.AddRegionStore(5, 20)
+
+	tc.UpdateStorageReadStats(1, 10.5*MB*statistics.StoreHeartBeatReportInterval, 10.5*MB*statistics.StoreHeartBeatReportInterval)
+	tc.UpdateStorageReadStats(2, 9.5*MB*statistics.StoreHeartBeatReportInterval, 9.5*MB*statistics.StoreHeartBeatReportInterval)
+	tc.UpdateStorageReadStats(3, 10.0*MB*statistics.StoreHeartBeatReportInterval, 10.0*MB*statistics.StoreHeartBeatReportInterval)
+	addRegionInfo(tc, statistics.Read, []testRegionInfo{
+		{1, []uint64{1, 2, 3}, 0.5 * MB, 0.5 * MB, 0},
+	})
+
+	// no uniform store filter
+	stddevThreshold = 0.0
+	clearPendingInfluence(hb.(*hotScheduler))
+	ops, _ := hb.Schedule(tc, false)
+	op := ops[0]
+	testutil.CheckTransferLeader(re, op, operator.OpHotRegion, 1, 2)
+
+}
+
 func TestHotCacheUpdateCache(t *testing.T) {
 	re := require.New(t)
 	ctx, cancel := context.WithCancel(context.Background())