server: resource ratio

server/balancer.go

@@ -63,7 +63,7 @@ func (cb *capacityBalancer) Balance(cluster *clusterInfo) (float64, *balanceOper
 	}
 
 	// Check diff score.
-	diff := source.getScore(cb.kind) - target.getScore(cb.kind)
+	diff := source.resourceRatio(cb.kind) - target.resourceRatio(cb.kind)
 	if diff < cb.cfg.MaxDiffScoreFraction {
 		return 0, nil, nil
 	}
@@ -112,7 +112,7 @@ func (lb *leaderBalancer) Balance(cluster *clusterInfo) (float64, *balanceOperat
 		return 0, nil, nil
 	}
 
-	diff := source.getScore(lb.kind) - target.getScore(lb.kind)
+	diff := source.resourceRatio(lb.kind) - target.resourceRatio(lb.kind)
 	if diff < lb.cfg.MaxDiffScoreFraction {
 		return 0, nil, nil
 	}

server/balancer_worker.go

@@ -256,15 +256,6 @@ func (bw *balancerWorker) checkReplicas(region *regionInfo) error {
 	return nil
 }
 
-func (bw *balancerWorker) storeScores(store *storeInfo) []int {
-	scores := make([]int, 0, len(bw.balancers))
-	for _, balancer := range bw.balancers {
-		score := store.getScore(balancer.GetResourceKind())
-		scores = append(scores, int(score*100))
-	}
-	return scores
-}
-
 func collectOperatorMetrics(bop *balanceOperator) map[string]uint64 {
 	metrics := make(map[string]uint64)
 	prefix := ""

server/cluster.go

@@ -426,8 +426,8 @@ func (c *RaftCluster) collectMetrics() {
 	regionTotalCount := 0
 	storageSize := uint64(0)
 	storageCapacity := uint64(0)
-	minUsedRatio, maxUsedRatio := float64(1.0), float64(0.0)
 	minLeaderRatio, maxLeaderRatio := float64(1.0), float64(0.0)
+	minStorageRatio, maxStorageRatio := float64(1.0), float64(0.0)
 
 	for _, s := range cluster.getStores() {
 		// Store state.
@@ -454,18 +454,18 @@ func (c *RaftCluster) collectMetrics() {
 		}
 
 		// Balance.
-		if minUsedRatio > s.usedRatio() {
-			minUsedRatio = s.usedRatio()
-		}
-		if maxUsedRatio < s.usedRatio() {
-			maxUsedRatio = s.usedRatio()
-		}
 		if minLeaderRatio > s.leaderRatio() {
 			minLeaderRatio = s.leaderRatio()
 		}
 		if maxLeaderRatio < s.leaderRatio() {
 			maxLeaderRatio = s.leaderRatio()
 		}
+		if minStorageRatio > s.storageRatio() {
+			minStorageRatio = s.storageRatio()
+		}
+		if maxStorageRatio < s.storageRatio() {
+			maxStorageRatio = s.storageRatio()
+		}
 	}
 
 	metrics := make(map[string]float64)
@@ -476,8 +476,8 @@ func (c *RaftCluster) collectMetrics() {
 	metrics["region_total_count"] = float64(regionTotalCount)
 	metrics["storage_size"] = float64(storageSize)
 	metrics["storage_capacity"] = float64(storageCapacity)
-	metrics["store_max_diff_used_ratio"] = maxUsedRatio - minUsedRatio
 	metrics["store_max_diff_leader_ratio"] = maxLeaderRatio - minLeaderRatio
+	metrics["store_max_diff_storage_ratio"] = maxStorageRatio - minStorageRatio
 
 	for label, value := range metrics {
 		clusterStatusGauge.WithLabelValues(label).Set(value)
@@ -585,8 +585,7 @@ func (c *RaftCluster) GetScores(store *metapb.Store, status *StoreStatus) []int
 		Store: store,
 		stats: status,
 	}
-
-	return c.balancerWorker.storeScores(storeInfo)
+	return storeInfo.resourceScores()
 }
 
 // FetchEvents fetches the operator events.

server/filter.go

@@ -97,11 +97,11 @@ func newCapacityFilter(cfg *BalanceConfig) *capacityFilter {
 }
 
 func (cf *capacityFilter) FilterSource(store *storeInfo) bool {
-	return store.usedRatio() <= cf.cfg.MinCapacityUsedRatio
+	return store.storageRatio() <= cf.cfg.MinCapacityUsedRatio
 }
 
 func (cf *capacityFilter) FilterTarget(store *storeInfo) bool {
-	return store.usedRatio() >= cf.cfg.MaxCapacityUsedRatio
+	return store.storageRatio() >= cf.cfg.MaxCapacityUsedRatio
 }
 
 type snapCountFilter struct {

server/selector.go

@@ -39,7 +39,7 @@ func (s *balanceSelector) SelectSource(stores []*storeInfo, filters ...Filter) *
 		if filterSource(store, filters) {
 			continue
 		}
-		if result == nil || result.getScore(s.kind) < store.getScore(s.kind) {
+		if result == nil || result.resourceRatio(s.kind) < store.resourceRatio(s.kind) {
 			result = store
 		}
 	}
@@ -54,7 +54,7 @@ func (s *balanceSelector) SelectTarget(stores []*storeInfo, filters ...Filter) *
 		if filterTarget(store, filters) {
 			continue
 		}
-		if result == nil || result.getScore(s.kind) > store.getScore(s.kind) {
+		if result == nil || result.resourceRatio(s.kind) > store.resourceRatio(s.kind) {
 			result = store
 		}
 	}

server/store.go

@@ -21,6 +21,14 @@ import (
 	"github.com/pingcap/kvproto/pkg/pdpb"
 )
 
+// ResourceKind distinguishes different kinds of resources.
+type ResourceKind int
+
+const (
+	leaderKind ResourceKind = iota + 1
+	storageKind
+)
+
 // storeInfo contains information about a store.
 // TODO: Export this to API directly.
 type storeInfo struct {
@@ -58,31 +66,38 @@ func (s *storeInfo) downTime() time.Duration {
 	return time.Since(s.stats.LastHeartbeatTS)
 }
 
-func (s *storeInfo) usedRatio() float64 {
-	if s.stats.GetCapacity() == 0 {
+func (s *storeInfo) leaderRatio() float64 {
+	if s.stats.TotalRegionCount == 0 {
 		return 0
 	}
-	return float64(s.stats.GetUsedSize()) / float64(s.stats.GetCapacity())
+	return float64(s.stats.LeaderRegionCount) / float64(s.stats.TotalRegionCount)
 }
 
-func (s *storeInfo) leaderRatio() float64 {
-	if s.stats.TotalRegionCount == 0 {
+func (s *storeInfo) storageRatio() float64 {
+	if s.stats.GetCapacity() == 0 {
 		return 0
 	}
-	return float64(s.stats.LeaderRegionCount) / float64(s.stats.TotalRegionCount)
+	return float64(s.stats.GetUsedSize()) / float64(s.stats.GetCapacity())
 }
 
-func (s *storeInfo) getScore(kind ResourceKind) float64 {
+func (s *storeInfo) resourceRatio(kind ResourceKind) float64 {
 	switch kind {
 	case leaderKind:
 		return s.leaderRatio()
 	case storageKind:
-		return s.usedRatio()
+		return s.storageRatio()
 	default:
 		return 0
 	}
 }
 
+func (s *storeInfo) resourceScores() []int {
+	var scores []int
+	scores = append(scores, int(s.leaderRatio()*100))
+	scores = append(scores, int(s.storageRatio()*100))
+	return scores
+}
+
 // StoreStatus contains information about a store's status.
 type StoreStatus struct {
 	*pdpb.StoreStats