diff --git a/pkg/cluster/cluster.go b/pkg/cluster/cluster.go
index 8bd2616f41f..ab97c7899db 100644
--- a/pkg/cluster/cluster.go
+++ b/pkg/cluster/cluster.go
@@ -35,12 +35,7 @@ type Cluster interface {
 func HandleStatsAsync(c Cluster, region *core.RegionInfo) {
 	c.GetHotStat().CheckWriteAsync(statistics.NewCheckExpiredItemTask(region))
 	c.GetHotStat().CheckReadAsync(statistics.NewCheckExpiredItemTask(region))
-	reportInterval := region.GetInterval()
-	interval := reportInterval.GetEndTimestamp() - reportInterval.GetStartTimestamp()
-	for _, peer := range region.GetPeers() {
-		peerInfo := core.NewPeerInfo(peer, region.GetWriteLoads(), interval)
-		c.GetHotStat().CheckWriteAsync(statistics.NewCheckPeerTask(peerInfo, region))
-	}
+	c.GetHotStat().CheckWriteAsync(statistics.NewCheckWritePeerTask(region))
 	c.GetCoordinator().GetSchedulersController().CheckTransferWitnessLeader(region)
 }
 
diff --git a/pkg/core/peer.go b/pkg/core/peer.go
index 659886e6d39..1f888ba58eb 100644
--- a/pkg/core/peer.go
+++ b/pkg/core/peer.go
@@ -77,34 +77,3 @@ func CountInJointState(peers ...*metapb.Peer) int {
 	}
 	return count
 }
-
-// PeerInfo provides peer information
-type PeerInfo struct {
-	*metapb.Peer
-	loads    []float64
-	interval uint64
-}
-
-// NewPeerInfo creates PeerInfo
-func NewPeerInfo(meta *metapb.Peer, loads []float64, interval uint64) *PeerInfo {
-	return &PeerInfo{
-		Peer:     meta,
-		loads:    loads,
-		interval: interval,
-	}
-}
-
-// GetLoads provides loads
-func (p *PeerInfo) GetLoads() []float64 {
-	return p.loads
-}
-
-// GetPeerID provides peer id
-func (p *PeerInfo) GetPeerID() uint64 {
-	return p.GetId()
-}
-
-// GetInterval returns reporting interval
-func (p *PeerInfo) GetInterval() uint64 {
-	return p.interval
-}
diff --git a/pkg/mcs/scheduling/server/cluster.go b/pkg/mcs/scheduling/server/cluster.go
index c6c365b03ad..d711ab2d4f6 100644
--- a/pkg/mcs/scheduling/server/cluster.go
+++ b/pkg/mcs/scheduling/server/cluster.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/pingcap/errors"
 	"github.com/pingcap/failpoint"
+	"github.com/pingcap/kvproto/pkg/metapb"
 	"github.com/pingcap/kvproto/pkg/pdpb"
 	"github.com/pingcap/kvproto/pkg/schedulingpb"
 	"github.com/pingcap/log"
@@ -442,8 +443,7 @@ func (c *Cluster) HandleStoreHeartbeat(heartbeat *schedulingpb.StoreHeartbeatReq
 			utils.RegionWriteKeys:     0,
 			utils.RegionWriteQueryNum: 0,
 		}
-		peerInfo := core.NewPeerInfo(peer, loads, interval)
-		c.hotStat.CheckReadAsync(statistics.NewCheckPeerTask(peerInfo, region))
+		c.hotStat.CheckReadAsync(statistics.NewCheckReadPeerTask(region, []*metapb.Peer{peer}, loads, interval))
 	}
 
 	// Here we will compare the reported regions with the previous hot peers to decide if it is still hot.
diff --git a/pkg/mock/mockcluster/mockcluster.go b/pkg/mock/mockcluster/mockcluster.go
index e5b3e39a502..3f9710c48fd 100644
--- a/pkg/mock/mockcluster/mockcluster.go
+++ b/pkg/mock/mockcluster/mockcluster.go
@@ -896,14 +896,7 @@ func (mc *Cluster) CheckRegionRead(region *core.RegionInfo) []*statistics.HotPee
 	items = append(items, expiredItems...)
 	reportInterval := region.GetInterval()
 	interval := reportInterval.GetEndTimestamp() - reportInterval.GetStartTimestamp()
-	for _, peer := range region.GetPeers() {
-		peerInfo := core.NewPeerInfo(peer, region.GetLoads(), interval)
-		item := mc.HotCache.CheckReadPeerSync(peerInfo, region)
-		if item != nil {
-			items = append(items, item)
-		}
-	}
-	return items
+	return append(items, mc.HotCache.CheckReadPeerSync(region, region.GetPeers(), region.GetLoads(), interval)...)
 }
 
 // CheckRegionWrite checks region write info with all peers
@@ -913,14 +906,7 @@ func (mc *Cluster) CheckRegionWrite(region *core.RegionInfo) []*statistics.HotPe
 	items = append(items, expiredItems...)
 	reportInterval := region.GetInterval()
 	interval := reportInterval.GetEndTimestamp() - reportInterval.GetStartTimestamp()
-	for _, peer := range region.GetPeers() {
-		peerInfo := core.NewPeerInfo(peer, region.GetLoads(), interval)
-		item := mc.HotCache.CheckWritePeerSync(peerInfo, region)
-		if item != nil {
-			items = append(items, item)
-		}
-	}
-	return items
+	return append(items, mc.HotCache.CheckWritePeerSync(region, region.GetPeers(), region.GetLoads(), interval)...)
 }
 
 // CheckRegionLeaderRead checks region read info with leader peer
@@ -930,13 +916,7 @@ func (mc *Cluster) CheckRegionLeaderRead(region *core.RegionInfo) []*statistics.
 	items = append(items, expiredItems...)
 	reportInterval := region.GetInterval()
 	interval := reportInterval.GetEndTimestamp() - reportInterval.GetStartTimestamp()
-	peer := region.GetLeader()
-	peerInfo := core.NewPeerInfo(peer, region.GetLoads(), interval)
-	item := mc.HotCache.CheckReadPeerSync(peerInfo, region)
-	if item != nil {
-		items = append(items, item)
-	}
-	return items
+	return append(items, mc.HotCache.CheckReadPeerSync(region, []*metapb.Peer{region.GetLeader()}, region.GetLoads(), interval)...)
 }
 
 // ObserveRegionsStats records the current stores stats from region stats.
diff --git a/pkg/statistics/hot_cache.go b/pkg/statistics/hot_cache.go
index 799fb240d10..26548c8b47e 100644
--- a/pkg/statistics/hot_cache.go
+++ b/pkg/statistics/hot_cache.go
@@ -17,6 +17,7 @@ package statistics
 import (
 	"context"
 
+	"github.com/pingcap/kvproto/pkg/metapb"
 	"github.com/smallnest/chanx"
 	"github.com/tikv/pd/pkg/core"
 	"github.com/tikv/pd/pkg/statistics/utils"
@@ -172,14 +173,14 @@ func (w *HotCache) Update(item *HotPeerStat, kind utils.RWType) {
 
 // CheckWritePeerSync checks the write status, returns update items.
 // This is used for mockcluster, for test purpose.
-func (w *HotCache) CheckWritePeerSync(peer *core.PeerInfo, region *core.RegionInfo) *HotPeerStat {
-	return w.writeCache.checkPeerFlow(peer, region)
+func (w *HotCache) CheckWritePeerSync(region *core.RegionInfo, peers []*metapb.Peer, loads []float64, interval uint64) []*HotPeerStat {
+	return w.writeCache.checkPeerFlow(region, peers, loads, interval)
 }
 
 // CheckReadPeerSync checks the read status, returns update items.
 // This is used for mockcluster, for test purpose.
-func (w *HotCache) CheckReadPeerSync(peer *core.PeerInfo, region *core.RegionInfo) *HotPeerStat {
-	return w.readCache.checkPeerFlow(peer, region)
+func (w *HotCache) CheckReadPeerSync(region *core.RegionInfo, peers []*metapb.Peer, loads []float64, interval uint64) []*HotPeerStat {
+	return w.readCache.checkPeerFlow(region, peers, loads, interval)
 }
 
 // ExpiredReadItems returns the read items which are already expired.
diff --git a/pkg/statistics/hot_cache_task.go b/pkg/statistics/hot_cache_task.go
index fa224b522ff..01731f3fe4d 100644
--- a/pkg/statistics/hot_cache_task.go
+++ b/pkg/statistics/hot_cache_task.go
@@ -17,6 +17,7 @@ package statistics
 import (
 	"context"
 
+	"github.com/pingcap/kvproto/pkg/metapb"
 	"github.com/tikv/pd/pkg/core"
 )
 
@@ -25,22 +26,46 @@ type FlowItemTask interface {
 	runTask(cache *hotPeerCache)
 }
 
-type checkPeerTask struct {
-	peerInfo   *core.PeerInfo
+type checkReadPeerTask struct {
 	regionInfo *core.RegionInfo
+	peers      []*metapb.Peer
+	loads      []float64
+	interval   uint64
 }
 
-// NewCheckPeerTask creates task to update peerInfo
-func NewCheckPeerTask(peerInfo *core.PeerInfo, regionInfo *core.RegionInfo) FlowItemTask {
-	return &checkPeerTask{
-		peerInfo:   peerInfo,
+// NewCheckReadPeerTask creates task to update peerInfo
+func NewCheckReadPeerTask(regionInfo *core.RegionInfo, peers []*metapb.Peer, loads []float64, interval uint64) FlowItemTask {
+	return &checkReadPeerTask{
 		regionInfo: regionInfo,
+		peers:      peers,
+		loads:      loads,
+		interval:   interval,
 	}
 }
 
-func (t *checkPeerTask) runTask(cache *hotPeerCache) {
-	stat := cache.checkPeerFlow(t.peerInfo, t.regionInfo)
-	if stat != nil {
+func (t *checkReadPeerTask) runTask(cache *hotPeerCache) {
+	stats := cache.checkPeerFlow(t.regionInfo, t.peers, t.loads, t.interval)
+	for _, stat := range stats {
+		cache.updateStat(stat)
+	}
+}
+
+type checkWritePeerTask struct {
+	region *core.RegionInfo
+}
+
+// NewCheckWritePeerTask creates task to update peerInfo
+func NewCheckWritePeerTask(region *core.RegionInfo) FlowItemTask {
+	return &checkWritePeerTask{
+		region: region,
+	}
+}
+
+func (t *checkWritePeerTask) runTask(cache *hotPeerCache) {
+	reportInterval := t.region.GetInterval()
+	interval := reportInterval.GetEndTimestamp() - reportInterval.GetStartTimestamp()
+	stats := cache.checkPeerFlow(t.region, t.region.GetPeers(), t.region.GetWriteLoads(), interval)
+	for _, stat := range stats {
 		cache.updateStat(stat)
 	}
 }
diff --git a/pkg/statistics/hot_peer_cache.go b/pkg/statistics/hot_peer_cache.go
index cd27dcad4c8..3a3d3519bd9 100644
--- a/pkg/statistics/hot_peer_cache.go
+++ b/pkg/statistics/hot_peer_cache.go
@@ -174,58 +174,61 @@ func (f *hotPeerCache) collectExpiredItems(region *core.RegionInfo) []*HotPeerSt
 // checkPeerFlow checks the flow information of a peer.
 // Notice: checkPeerFlow couldn't be used concurrently.
 // checkPeerFlow will update oldItem's rollingLoads into newItem, thus we should use write lock here.
-func (f *hotPeerCache) checkPeerFlow(peer *core.PeerInfo, region *core.RegionInfo) *HotPeerStat {
-	interval := peer.GetInterval()
+func (f *hotPeerCache) checkPeerFlow(region *core.RegionInfo, peers []*metapb.Peer, deltaLoads []float64, interval uint64) []*HotPeerStat {
 	if Denoising && interval < HotRegionReportMinInterval { // for test or simulator purpose
 		return nil
 	}
-	storeID := peer.GetStoreId()
-	deltaLoads := peer.GetLoads()
+
 	f.collectPeerMetrics(deltaLoads, interval) // update metrics
 	regionID := region.GetID()
-	oldItem := f.getOldHotPeerStat(regionID, storeID)
-
-	// check whether the peer is allowed to be inherited
-	source := utils.Direct
-	if oldItem == nil {
-		for _, storeID := range f.getAllStoreIDs(region) {
-			oldItem = f.getOldHotPeerStat(regionID, storeID)
-			if oldItem != nil && oldItem.allowInherited {
-				source = utils.Inherit
-				break
+
+	regionPeers := region.GetPeers()
+	stats := make([]*HotPeerStat, 0, len(peers))
+	for _, peer := range peers {
+		storeID := peer.GetStoreId()
+		oldItem := f.getOldHotPeerStat(regionID, storeID)
+
+		// check whether the peer is allowed to be inherited
+		source := utils.Direct
+		if oldItem == nil {
+			for _, storeID := range f.getAllStoreIDs(region) {
+				oldItem = f.getOldHotPeerStat(regionID, storeID)
+				if oldItem != nil && oldItem.allowInherited {
+					source = utils.Inherit
+					break
+				}
 			}
 		}
-	}
-
-	// check new item whether is hot
-	if oldItem == nil {
-		regionStats := f.kind.RegionStats()
-		thresholds := f.calcHotThresholds(storeID)
-		isHot := slice.AnyOf(regionStats, func(i int) bool {
-			return deltaLoads[regionStats[i]]/float64(interval) >= thresholds[i]
-		})
-		if !isHot {
-			return nil
+		// check new item whether is hot
+		if oldItem == nil {
+			regionStats := f.kind.RegionStats()
+			thresholds := f.calcHotThresholds(storeID)
+			isHot := slice.AnyOf(regionStats, func(i int) bool {
+				return deltaLoads[regionStats[i]]/float64(interval) >= thresholds[i]
+			})
+			if !isHot {
+				continue
+			}
 		}
-	}
-
-	peers := region.GetPeers()
-	newItem := &HotPeerStat{
-		StoreID:    storeID,
-		RegionID:   regionID,
-		Loads:      f.kind.GetLoadRatesFromPeer(peer),
-		isLeader:   region.GetLeader().GetStoreId() == storeID,
-		actionType: utils.Update,
-		stores:     make([]uint64, len(peers)),
-	}
-	for i, peer := range peers {
-		newItem.stores[i] = peer.GetStoreId()
-	}
 
-	if oldItem == nil {
-		return f.updateNewHotPeerStat(newItem, deltaLoads, time.Duration(interval)*time.Second)
+		newItem := &HotPeerStat{
+			StoreID:    storeID,
+			RegionID:   regionID,
+			Loads:      f.kind.GetLoadRates(deltaLoads, interval),
+			isLeader:   region.GetLeader().GetStoreId() == storeID,
+			actionType: utils.Update,
+			stores:     make([]uint64, len(regionPeers)),
+		}
+		for i, peer := range regionPeers {
+			newItem.stores[i] = peer.GetStoreId()
+		}
+		if oldItem == nil {
+			stats = append(stats, f.updateNewHotPeerStat(newItem, deltaLoads, time.Duration(interval)*time.Second))
+			continue
+		}
+		stats = append(stats, f.updateHotPeerStat(region, newItem, oldItem, deltaLoads, time.Duration(interval)*time.Second, source))
 	}
-	return f.updateHotPeerStat(region, newItem, oldItem, deltaLoads, time.Duration(interval)*time.Second, source)
+	return stats
 }
 
 // checkColdPeer checks the collect the un-heartbeat peer and maintain it.
diff --git a/pkg/statistics/hot_peer_cache_test.go b/pkg/statistics/hot_peer_cache_test.go
index 36f922d3830..c116e020f54 100644
--- a/pkg/statistics/hot_peer_cache_test.go
+++ b/pkg/statistics/hot_peer_cache_test.go
@@ -109,14 +109,7 @@ func checkFlow(cache *hotPeerCache, region *core.RegionInfo, peers []*metapb.Pee
 	reportInterval := region.GetInterval()
 	interval := reportInterval.GetEndTimestamp() - reportInterval.GetStartTimestamp()
 	res = append(res, cache.collectExpiredItems(region)...)
-	for _, peer := range peers {
-		peerInfo := core.NewPeerInfo(peer, region.GetLoads(), interval)
-		item := cache.checkPeerFlow(peerInfo, region)
-		if item != nil {
-			res = append(res, item)
-		}
-	}
-	return res
+	return append(res, cache.checkPeerFlow(region, peers, region.GetLoads(), interval)...)
 }
 
 func updateFlow(cache *hotPeerCache, res []*HotPeerStat) []*HotPeerStat {
@@ -318,13 +311,13 @@ func TestUpdateHotPeerStat(t *testing.T) {
 	}()
 
 	// skip interval=0
-	interval := 0
+	interval := uint64(0)
 	deltaLoads := []float64{0.0, 0.0, 0.0}
 	utils.MinHotThresholds[utils.RegionReadBytes] = 0.0
 	utils.MinHotThresholds[utils.RegionReadKeys] = 0.0
 	utils.MinHotThresholds[utils.RegionReadQueryNum] = 0.0
 
-	newItem := cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
+	newItem := cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
 	re.Nil(newItem)
 
 	// new peer, interval is larger than report interval, but no hot
@@ -333,8 +326,8 @@ func TestUpdateHotPeerStat(t *testing.T) {
 	utils.MinHotThresholds[utils.RegionReadBytes] = 1.0
 	utils.MinHotThresholds[utils.RegionReadKeys] = 1.0
 	utils.MinHotThresholds[utils.RegionReadQueryNum] = 1.0
-	newItem = cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
-	re.Nil(newItem)
+	newItem = cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
+	re.Empty(newItem)
 
 	// new peer, interval is less than report interval
 	interval = 4
@@ -342,50 +335,49 @@ func TestUpdateHotPeerStat(t *testing.T) {
 	utils.MinHotThresholds[utils.RegionReadBytes] = 0.0
 	utils.MinHotThresholds[utils.RegionReadKeys] = 0.0
 	utils.MinHotThresholds[utils.RegionReadQueryNum] = 0.0
-	newItem = cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
+	newItem = cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
 	re.NotNil(newItem)
-	re.Equal(0, newItem.HotDegree)
-	re.Equal(0, newItem.AntiCount)
+	re.Equal(0, newItem[0].HotDegree)
+	re.Equal(0, newItem[0].AntiCount)
 	// sum of interval is less than report interval
-	interval = 4
 	deltaLoads = []float64{60.0, 60.0, 60.0}
-	cache.updateStat(newItem)
-	newItem = cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
-	re.Equal(0, newItem.HotDegree)
-	re.Equal(0, newItem.AntiCount)
+	cache.updateStat(newItem[0])
+	newItem = cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
+	re.Equal(0, newItem[0].HotDegree)
+	re.Equal(0, newItem[0].AntiCount)
 	// sum of interval is larger than report interval, and hot
-	newItem.AntiCount = utils.Read.DefaultAntiCount()
-	cache.updateStat(newItem)
-	newItem = cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
-	re.Equal(1, newItem.HotDegree)
-	re.Equal(2*m, newItem.AntiCount)
+	newItem[0].AntiCount = utils.Read.DefaultAntiCount()
+	cache.updateStat(newItem[0])
+	newItem = cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
+	re.Equal(1, newItem[0].HotDegree)
+	re.Equal(2*m, newItem[0].AntiCount)
 	// sum of interval is less than report interval
-	cache.updateStat(newItem)
-	newItem = cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
-	re.Equal(1, newItem.HotDegree)
-	re.Equal(2*m, newItem.AntiCount)
+	cache.updateStat(newItem[0])
+	newItem = cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
+	re.Equal(1, newItem[0].HotDegree)
+	re.Equal(2*m, newItem[0].AntiCount)
 	// sum of interval is larger than report interval, and hot
 	interval = 10
-	cache.updateStat(newItem)
-	newItem = cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
-	re.Equal(2, newItem.HotDegree)
-	re.Equal(2*m, newItem.AntiCount)
+	cache.updateStat(newItem[0])
+	newItem = cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
+	re.Equal(2, newItem[0].HotDegree)
+	re.Equal(2*m, newItem[0].AntiCount)
 	// sum of interval is larger than report interval, and cold
 	utils.MinHotThresholds[utils.RegionReadBytes] = 10.0
 	utils.MinHotThresholds[utils.RegionReadKeys] = 10.0
 	utils.MinHotThresholds[utils.RegionReadQueryNum] = 10.0
-	cache.updateStat(newItem)
-	newItem = cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
-	re.Equal(1, newItem.HotDegree)
-	re.Equal(2*m-1, newItem.AntiCount)
+	cache.updateStat(newItem[0])
+	newItem = cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
+	re.Equal(1, newItem[0].HotDegree)
+	re.Equal(2*m-1, newItem[0].AntiCount)
 	// sum of interval is larger than report interval, and cold
 	for i := 0; i < 2*m-1; i++ {
-		cache.updateStat(newItem)
-		newItem = cache.checkPeerFlow(core.NewPeerInfo(peer, deltaLoads, uint64(interval)), region)
+		cache.updateStat(newItem[0])
+		newItem = cache.checkPeerFlow(region, []*metapb.Peer{peer}, deltaLoads, interval)
 	}
-	re.Less(newItem.HotDegree, 0)
-	re.Equal(0, newItem.AntiCount)
-	re.Equal(utils.Remove, newItem.actionType)
+	re.Less(newItem[0].HotDegree, 0)
+	re.Equal(0, newItem[0].AntiCount)
+	re.Equal(utils.Remove, newItem[0].actionType)
 }
 
 func TestThresholdWithUpdateHotPeerStat(t *testing.T) {
@@ -688,9 +680,8 @@ func TestHotPeerCacheTopNThreshold(t *testing.T) {
 					StartTimestamp: start,
 					EndTimestamp:   end,
 				}))
-				newPeer := core.NewPeerInfo(meta.Peers[0], region.GetLoads(), end-start)
-				stat := cache.checkPeerFlow(newPeer, newRegion)
-				if stat != nil {
+				stats := cache.checkPeerFlow(newRegion, newRegion.GetPeers(), newRegion.GetLoads(), end-start)
+				for _, stat := range stats {
 					cache.updateStat(stat)
 				}
 			}
@@ -717,22 +708,11 @@ func TestHotPeerCacheTopNThreshold(t *testing.T) {
 func BenchmarkCheckRegionFlow(b *testing.B) {
 	cache := NewHotPeerCache(context.Background(), utils.Read)
 	region := buildRegion(utils.Read, 3, 10)
-	peerInfos := make([]*core.PeerInfo, 0)
-	for _, peer := range region.GetPeers() {
-		peerInfo := core.NewPeerInfo(peer, region.GetLoads(), 10)
-		peerInfos = append(peerInfos, peerInfo)
-	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		items := make([]*HotPeerStat, 0)
-		for _, peerInfo := range peerInfos {
-			item := cache.checkPeerFlow(peerInfo, region)
-			if item != nil {
-				items = append(items, item)
-			}
-		}
-		for _, ret := range items {
-			cache.updateStat(ret)
+		stats := cache.checkPeerFlow(region, region.GetPeers(), region.GetLoads(), 10)
+		for _, stat := range stats {
+			cache.updateStat(stat)
 		}
 	}
 }
diff --git a/pkg/statistics/utils/kind.go b/pkg/statistics/utils/kind.go
index 4d44b8d57e1..089732f759f 100644
--- a/pkg/statistics/utils/kind.go
+++ b/pkg/statistics/utils/kind.go
@@ -14,10 +14,6 @@
 
 package utils
 
-import (
-	"github.com/tikv/pd/pkg/core"
-)
-
 const (
 	// BytePriority indicates hot-region-scheduler prefer byte dim
 	BytePriority = "byte"
@@ -230,10 +226,8 @@ func (rw RWType) DefaultAntiCount() int {
 	}
 }
 
-// GetLoadRatesFromPeer gets the load rates of the read or write type from PeerInfo.
-func (rw RWType) GetLoadRatesFromPeer(peer *core.PeerInfo) []float64 {
-	deltaLoads := peer.GetLoads()
-	interval := peer.GetInterval()
+// GetLoadRates gets the load rates of the read or write type.
+func (rw RWType) GetLoadRates(deltaLoads []float64, interval uint64) []float64 {
 	loads := make([]float64, DimLen)
 	for dim, k := range rw.RegionStats() {
 		loads[dim] = deltaLoads[k] / float64(interval)
diff --git a/server/cluster/cluster.go b/server/cluster/cluster.go
index 148b43541a2..057814b718b 100644
--- a/server/cluster/cluster.go
+++ b/server/cluster/cluster.go
@@ -959,8 +959,7 @@ func (c *RaftCluster) HandleStoreHeartbeat(heartbeat *pdpb.StoreHeartbeatRequest
 				utils.RegionWriteKeys:     0,
 				utils.RegionWriteQueryNum: 0,
 			}
-			peerInfo := core.NewPeerInfo(peer, loads, interval)
-			c.hotStat.CheckReadAsync(statistics.NewCheckPeerTask(peerInfo, region))
+			c.hotStat.CheckReadAsync(statistics.NewCheckReadPeerTask(region, []*metapb.Peer{peer}, loads, interval))
 		}
 	}
 	for _, stat := range stats.GetSnapshotStats() {
diff --git a/server/cluster/cluster_test.go b/server/cluster/cluster_test.go
index 945e354bb6c..0f08153c8ae 100644
--- a/server/cluster/cluster_test.go
+++ b/server/cluster/cluster_test.go
@@ -33,6 +33,7 @@ import (
 	"github.com/pingcap/kvproto/pkg/metapb"
 	"github.com/pingcap/kvproto/pkg/pdpb"
 	"github.com/stretchr/testify/require"
+	"github.com/tikv/pd/pkg/cluster"
 	"github.com/tikv/pd/pkg/core"
 	"github.com/tikv/pd/pkg/core/constant"
 	"github.com/tikv/pd/pkg/core/storelimit"
@@ -3730,3 +3731,34 @@ func waitNoResponse(re *require.Assertions, stream mockhbstream.HeartbeatStream)
 		return res == nil
 	})
 }
+
+func BenchmarkHandleStatsAsync(b *testing.B) {
+	// Setup: create a new instance of Cluster
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	_, opt, _ := newTestScheduleConfig()
+	c := newTestRaftCluster(ctx, mockid.NewIDAllocator(), opt, storage.NewStorageWithMemoryBackend())
+	c.coordinator = schedule.NewCoordinator(ctx, c, nil)
+	c.SetPrepared()
+	region := core.NewRegionInfo(&metapb.Region{
+		Id: 1,
+		RegionEpoch: &metapb.RegionEpoch{
+			ConfVer: 1,
+			Version: 1,
+		},
+		StartKey: []byte{byte(2)},
+		EndKey:   []byte{byte(3)},
+		Peers:    []*metapb.Peer{{Id: 11, StoreId: uint64(1)}},
+	}, nil,
+		core.SetApproximateSize(10),
+		core.SetReportInterval(0, 10),
+	)
+
+	// Reset timer after setup
+	b.ResetTimer()
+	// Run HandleStatsAsync b.N times
+	for i := 0; i < b.N; i++ {
+		cluster.HandleStatsAsync(c, region)
+	}
+}
diff --git a/tools/pd-ctl/tests/hot/hot_test.go b/tools/pd-ctl/tests/hot/hot_test.go
index 7661704aa41..f65b811b36a 100644
--- a/tools/pd-ctl/tests/hot/hot_test.go
+++ b/tools/pd-ctl/tests/hot/hot_test.go
@@ -188,11 +188,10 @@ func (suite *hotTestSuite) checkHot(cluster *pdTests.TestCluster) {
 					Id:      100 + regionIDCounter,
 					StoreId: hotStoreID,
 				}
-				peerInfo := core.NewPeerInfo(leader, loads, reportInterval)
 				region := core.NewRegionInfo(&metapb.Region{
 					Id: hotRegionID,
 				}, leader)
-				hotStat.CheckReadAsync(statistics.NewCheckPeerTask(peerInfo, region))
+				hotStat.CheckReadAsync(statistics.NewCheckReadPeerTask(region, []*metapb.Peer{leader}, loads, reportInterval))
 				testutil.Eventually(re, func() bool {
 					hotPeerStat := getHotPeerStat(utils.Read, hotRegionID, hotStoreID)
 					return hotPeerStat != nil