statistics: reduce unnecessary cpu time

server/core/peer.go

@@ -94,11 +94,6 @@ func NewPeerInfo(meta *metapb.Peer, loads []float64, interval uint64) *PeerInfo
 	}
 }
 
-// GetStoreID provides located storeID
-func (p *PeerInfo) GetStoreID() uint64 {
-	return p.GetStoreId()
-}
-
 // GetLoads provides loads
 func (p *PeerInfo) GetLoads() []float64 {
 	return p.loads

server/statistics/hot_cache.go

@@ -20,6 +20,11 @@ import (
 	"github.com/tikv/pd/server/core"
 )
 
+var (
+	readTaskMetrics  = hotCacheFlowQueueStatusGauge.WithLabelValues(Read.String())
+	writeTaskMetrics = hotCacheFlowQueueStatusGauge.WithLabelValues(Write.String())
+)
+
 // HotCache is a cache hold hot regions.
 type HotCache struct {
 	ctx        context.Context
@@ -105,27 +110,15 @@ func (w *HotCache) GetHotPeerStat(kind RWType, regionID, storeID uint64) *HotPee
 
 // CollectMetrics collects the hot cache metrics.
 func (w *HotCache) CollectMetrics() {
-	writeMetricsTask := newCollectMetricsTask("write")
-	readMetricsTask := newCollectMetricsTask("read")
-	w.CheckWriteAsync(writeMetricsTask)
-	w.CheckReadAsync(readMetricsTask)
+	w.CheckWriteAsync(newCollectMetricsTask())
+	w.CheckReadAsync(newCollectMetricsTask())
 }
 
 // ResetMetrics resets the hot cache metrics.
 func (w *HotCache) ResetMetrics() {
 	hotCacheStatusGauge.Reset()
 }
 
-func incMetrics(name string, storeID uint64, kind RWType) {
-	store := storeTag(storeID)
-	switch kind {
-	case Write:
-		hotCacheStatusGauge.WithLabelValues(name, store, "write").Inc()
-	case Read:
-		hotCacheStatusGauge.WithLabelValues(name, store, "read").Inc()
-	}
-}
-
 func (w *HotCache) updateItems(queue <-chan FlowItemTask, runTask func(task FlowItemTask)) {
 	for {
 		select {
@@ -141,15 +134,15 @@ func (w *HotCache) runReadTask(task FlowItemTask) {
 	if task != nil {
 		// TODO: do we need a run-task timeout to protect the queue won't be stuck by a task?
 		task.runTask(w.readCache)
-		hotCacheFlowQueueStatusGauge.WithLabelValues(Read.String()).Set(float64(len(w.readCache.taskQueue)))
+		readTaskMetrics.Set(float64(len(w.readCache.taskQueue)))
 	}
 }
 
 func (w *HotCache) runWriteTask(task FlowItemTask) {
 	if task != nil {
 		// TODO: do we need a run-task timeout to protect the queue won't be stuck by a task?
 		task.runTask(w.writeCache)
-		hotCacheFlowQueueStatusGauge.WithLabelValues(Write.String()).Set(float64(len(w.writeCache.taskQueue)))
+		writeTaskMetrics.Set(float64(len(w.writeCache.taskQueue)))
 	}
 }
 

server/statistics/hot_cache_task.go

@@ -140,17 +140,14 @@ func (t *checkRegionHotTask) waitRet(ctx context.Context) bool {
 }
 
 type collectMetricsTask struct {
-	typ string
 }
 
-func newCollectMetricsTask(typ string) *collectMetricsTask {
-	return &collectMetricsTask{
-		typ: typ,
-	}
+func newCollectMetricsTask() *collectMetricsTask {
+	return &collectMetricsTask{}
 }
 
 func (t *collectMetricsTask) runTask(cache *hotPeerCache) {
-	cache.collectMetrics(t.typ)
+	cache.collectMetrics()
 }
 
 type getHotPeerStatTask struct {

server/statistics/hot_peer.go

@@ -18,6 +18,7 @@ import (
 	"math"
 	"time"
 
+	"github.com/pingcap/log"
 	"github.com/tikv/pd/pkg/movingaverage"
 	"github.com/tikv/pd/pkg/slice"
 	"github.com/tikv/pd/pkg/utils/syncutil"
@@ -126,18 +127,20 @@ func (stat *HotPeerStat) Less(dim int, than TopNItem) bool {
 }
 
 // Log is used to output some info
-func (stat *HotPeerStat) Log(str string, level func(msg string, fields ...zap.Field)) {
-	level(str,
-		zap.Uint64("region-id", stat.RegionID),
-		zap.Bool("is-leader", stat.isLeader),
-		zap.Float64s("loads", stat.GetLoads()),
-		zap.Float64s("loads-instant", stat.Loads),
-		zap.Int("hot-degree", stat.HotDegree),
-		zap.Int("hot-anti-count", stat.AntiCount),
-		zap.Duration("sum-interval", stat.getIntervalSum()),
-		zap.Bool("allow-inherited", stat.allowInherited),
-		zap.String("action-type", stat.actionType.String()),
-		zap.Time("last-transfer-leader-time", stat.lastTransferLeaderTime))
+func (stat *HotPeerStat) Log(str string) {
+	if log.GetLevel() <= zap.DebugLevel {
+		log.Debug(str,
+			zap.Uint64("region-id", stat.RegionID),
+			zap.Bool("is-leader", stat.isLeader),
+			zap.Float64s("loads", stat.GetLoads()),
+			zap.Float64s("loads-instant", stat.Loads),
+			zap.Int("hot-degree", stat.HotDegree),
+			zap.Int("hot-anti-count", stat.AntiCount),
+			zap.Duration("sum-interval", stat.getIntervalSum()),
+			zap.Bool("allow-inherited", stat.allowInherited),
+			zap.String("action-type", stat.actionType.String()),
+			zap.Time("last-transfer-leader-time", stat.lastTransferLeaderTime))
+	}
 }
 
 // IsNeedCoolDownTransferLeader use cooldown time after transfer leader to avoid unnecessary schedule