Skip to content

Commit

Permalink
Remove the unused code
Browse files Browse the repository at this point in the history 
Signed-off-by: JmPotato <[email protected]>
  • Loading branch information
@JmPotato
JmPotato committed May 21, 2024
1 parent b772971 commit 8764d02
Show file tree
Hide file tree
Showing 4 changed files with 27 additions and 57 deletions.
33 changes: 2 additions & 31 deletions pkg/core/region.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1673,25 +1673,17 @@ func (r *RegionsInfo) GetStoreWitnessCount(storeID uint64) int {
return r.witnesses[storeID].length()
}

// RandPendingRegion randomly gets a store's region with a pending peer.
func (r *RegionsInfo) RandPendingRegion(storeID uint64, ranges []KeyRange) *RegionInfo {
r.st.RLock()
defer r.st.RUnlock()
return r.pendingPeers[storeID].RandomRegion(ranges)
}

// RandPendingRegions randomly gets a store's n regions with a pending peer.
func (r *RegionsInfo) RandPendingRegions(storeID uint64, ranges []KeyRange) []*RegionInfo {
r.st.RLock()
defer r.st.RUnlock()
return r.pendingPeers[storeID].RandomRegions(randomRegionMaxRetry, ranges)
}

// RandLeaderRegion randomly gets a store's leader region.
func (r *RegionsInfo) RandLeaderRegion(storeID uint64, ranges []KeyRange) *RegionInfo {
func (r *RegionsInfo) randLeaderRegion(storeID uint64, ranges []KeyRange) *RegionInfo {
r.st.RLock()
defer r.st.RUnlock()
return r.leaders[storeID].RandomRegion(ranges)
return r.leaders[storeID].randomRegion(ranges)
}

// RandLeaderRegions randomly gets a store's n leader regions.
Expand All @@ -1701,41 +1693,20 @@ func (r *RegionsInfo) RandLeaderRegions(storeID uint64, ranges []KeyRange) []*Re
return r.leaders[storeID].RandomRegions(randomRegionMaxRetry, ranges)
}

// RandFollowerRegion randomly gets a store's follower region.
func (r *RegionsInfo) RandFollowerRegion(storeID uint64, ranges []KeyRange) *RegionInfo {
r.st.RLock()
defer r.st.RUnlock()
return r.followers[storeID].RandomRegion(ranges)
}

// RandFollowerRegions randomly gets a store's n follower regions.
func (r *RegionsInfo) RandFollowerRegions(storeID uint64, ranges []KeyRange) []*RegionInfo {
r.st.RLock()
defer r.st.RUnlock()
return r.followers[storeID].RandomRegions(randomRegionMaxRetry, ranges)
}

// RandLearnerRegion randomly gets a store's learner region.
func (r *RegionsInfo) RandLearnerRegion(storeID uint64, ranges []KeyRange) *RegionInfo {
r.st.RLock()
defer r.st.RUnlock()
return r.learners[storeID].RandomRegion(ranges)
}

// RandLearnerRegions randomly gets a store's n learner regions.
func (r *RegionsInfo) RandLearnerRegions(storeID uint64, ranges []KeyRange) []*RegionInfo {
r.st.RLock()
defer r.st.RUnlock()
return r.learners[storeID].RandomRegions(randomRegionMaxRetry, ranges)
}

// RandWitnessRegion randomly gets a store's witness region.
func (r *RegionsInfo) RandWitnessRegion(storeID uint64, ranges []KeyRange) *RegionInfo {
r.st.RLock()
defer r.st.RUnlock()
return r.witnesses[storeID].RandomRegion(ranges)
}

// RandWitnessRegions randomly gets a store's n witness regions.
func (r *RegionsInfo) RandWitnessRegions(storeID uint64, ranges []KeyRange) []*RegionInfo {
r.st.RLock()
Expand Down
2 changes: 1 addition & 1 deletion pkg/core/region_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -657,7 +657,7 @@ func BenchmarkRandomRegion(b *testing.B) {
b.Run("random region", func(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
regions.RandLeaderRegion(1, nil)
regions.randLeaderRegion(1, nil)
}
})
b.Run("random regions", func(b *testing.B) {
Expand Down
3 changes: 1 addition & 2 deletions pkg/core/region_tree.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -328,8 +328,7 @@ func (t *regionTree) getAdjacentItem(item *regionItem) (prev *regionItem, next *
return prev, next
}

// RandomRegion returns a random region within the given ranges.
func (t *regionTree) RandomRegion(ranges []KeyRange) *RegionInfo {
func (t *regionTree) randomRegion(ranges []KeyRange) *RegionInfo {
regions := t.RandomRegions(1, ranges)
if len(regions) == 0 {
return nil
Expand Down
46 changes: 23 additions & 23 deletions pkg/core/region_tree_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -274,12 +274,12 @@ func TestRegionTreeSplitAndMerge(t *testing.T) {
func TestRandomRegion(t *testing.T) {
re := require.New(t)
tree := newRegionTree()
r := tree.RandomRegion(nil)
r := tree.randomRegion(nil)
re.Nil(r)

regionA := NewTestRegionInfo(1, 1, []byte(""), []byte("g"))
updateNewItem(tree, regionA)
ra := tree.RandomRegion([]KeyRange{NewKeyRange("", "")})
ra := tree.randomRegion([]KeyRange{NewKeyRange("", "")})
re.Equal(regionA, ra)
ra2 := tree.RandomRegions(2, []KeyRange{NewKeyRange("", "")})
re.Equal([]*RegionInfo{regionA, regionA}, ra2)
Expand All @@ -291,20 +291,20 @@ func TestRandomRegion(t *testing.T) {
updateNewItem(tree, regionC)
updateNewItem(tree, regionD)

rb := tree.RandomRegion([]KeyRange{NewKeyRange("g", "n")})
rb := tree.randomRegion([]KeyRange{NewKeyRange("g", "n")})
re.Equal(regionB, rb)
rc := tree.RandomRegion([]KeyRange{NewKeyRange("n", "t")})
rc := tree.randomRegion([]KeyRange{NewKeyRange("n", "t")})
re.Equal(regionC, rc)
rd := tree.RandomRegion([]KeyRange{NewKeyRange("t", "")})
rd := tree.randomRegion([]KeyRange{NewKeyRange("t", "")})
re.Equal(regionD, rd)

rf := tree.RandomRegion([]KeyRange{NewKeyRange("", "a")})
rf := tree.randomRegion([]KeyRange{NewKeyRange("", "a")})
re.Nil(rf)
rf = tree.RandomRegion([]KeyRange{NewKeyRange("o", "s")})
rf = tree.randomRegion([]KeyRange{NewKeyRange("o", "s")})
re.Nil(rf)
rf = tree.RandomRegion([]KeyRange{NewKeyRange("", "a")})
rf = tree.randomRegion([]KeyRange{NewKeyRange("", "a")})
re.Nil(rf)
rf = tree.RandomRegion([]KeyRange{NewKeyRange("z", "")})
rf = tree.randomRegion([]KeyRange{NewKeyRange("z", "")})
re.Nil(rf)

checkRandomRegion(re, tree, []*RegionInfo{regionA, regionB, regionC, regionD}, []KeyRange{NewKeyRange("", "")})
Expand All @@ -317,43 +317,43 @@ func TestRandomRegion(t *testing.T) {
func TestRandomRegionDiscontinuous(t *testing.T) {
re := require.New(t)
tree := newRegionTree()
r := tree.RandomRegion([]KeyRange{NewKeyRange("c", "f")})
r := tree.randomRegion([]KeyRange{NewKeyRange("c", "f")})
re.Nil(r)

// test for single region
regionA := NewTestRegionInfo(1, 1, []byte("c"), []byte("f"))
updateNewItem(tree, regionA)
ra := tree.RandomRegion([]KeyRange{NewKeyRange("c", "e")})
ra := tree.randomRegion([]KeyRange{NewKeyRange("c", "e")})
re.Nil(ra)
ra = tree.RandomRegion([]KeyRange{NewKeyRange("c", "f")})
ra = tree.randomRegion([]KeyRange{NewKeyRange("c", "f")})
re.Equal(regionA, ra)
ra = tree.RandomRegion([]KeyRange{NewKeyRange("c", "g")})
ra = tree.randomRegion([]KeyRange{NewKeyRange("c", "g")})
re.Equal(regionA, ra)
ra = tree.RandomRegion([]KeyRange{NewKeyRange("a", "e")})
ra = tree.randomRegion([]KeyRange{NewKeyRange("a", "e")})
re.Nil(ra)
ra = tree.RandomRegion([]KeyRange{NewKeyRange("a", "f")})
ra = tree.randomRegion([]KeyRange{NewKeyRange("a", "f")})
re.Equal(regionA, ra)
ra = tree.RandomRegion([]KeyRange{NewKeyRange("a", "g")})
ra = tree.randomRegion([]KeyRange{NewKeyRange("a", "g")})
re.Equal(regionA, ra)

regionB := NewTestRegionInfo(2, 2, []byte("n"), []byte("x"))
updateNewItem(tree, regionB)
rb := tree.RandomRegion([]KeyRange{NewKeyRange("g", "x")})
rb := tree.randomRegion([]KeyRange{NewKeyRange("g", "x")})
re.Equal(regionB, rb)
rb = tree.RandomRegion([]KeyRange{NewKeyRange("g", "y")})
rb = tree.randomRegion([]KeyRange{NewKeyRange("g", "y")})
re.Equal(regionB, rb)
rb = tree.RandomRegion([]KeyRange{NewKeyRange("n", "y")})
rb = tree.randomRegion([]KeyRange{NewKeyRange("n", "y")})
re.Equal(regionB, rb)
rb = tree.RandomRegion([]KeyRange{NewKeyRange("o", "y")})
rb = tree.randomRegion([]KeyRange{NewKeyRange("o", "y")})
re.Nil(rb)

regionC := NewTestRegionInfo(3, 3, []byte("z"), []byte(""))
updateNewItem(tree, regionC)
rc := tree.RandomRegion([]KeyRange{NewKeyRange("y", "")})
rc := tree.randomRegion([]KeyRange{NewKeyRange("y", "")})
re.Equal(regionC, rc)
regionD := NewTestRegionInfo(4, 4, []byte(""), []byte("a"))
updateNewItem(tree, regionD)
rd := tree.RandomRegion([]KeyRange{NewKeyRange("", "b")})
rd := tree.randomRegion([]KeyRange{NewKeyRange("", "b")})
re.Equal(regionD, rd)

checkRandomRegion(re, tree, []*RegionInfo{regionA, regionB, regionC, regionD}, []KeyRange{NewKeyRange("", "")})
Expand All @@ -367,7 +367,7 @@ func updateNewItem(tree *regionTree, region *RegionInfo) {
func checkRandomRegion(re *require.Assertions, tree *regionTree, regions []*RegionInfo, ranges []KeyRange) {
keys := make(map[string]struct{})
for i := 0; i < 10000 && len(keys) < len(regions); i++ {
re := tree.RandomRegion(ranges)
re := tree.randomRegion(ranges)
if re == nil {
continue
}
Expand Down

0 comments on commit 8764d02

Please sign in to comment.