Skip to content

Commit 7fa0925

Browse files
bufferfliesbufferflies
committed
delete range
Signed-off-by: 童剑 <[email protected]>
1 parent 8d91e0d commit 7fa0925

File tree

7 files changed

+114
-60
lines changed

7 files changed

+114
-60
lines changed

‎pkg/schedule/rangelist/key_range_manager.go

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,10 +15,12 @@
1515
package rangelist
1616

1717
import (
18-
"github.com/tikv/pd/pkg/utils/keyutil"
1918
"sync"
19+
20+
"github.com/tikv/pd/pkg/utils/keyutil"
2021
)
2122

23+
// KeyRangeManager is a manager for key ranges.
2224
type KeyRangeManager struct {
2325
sync.Mutex
2426
sortedKeyRanges *keyutil.KeyRanges
@@ -31,12 +33,14 @@ func NewKeyRangeManager() *KeyRangeManager {
3133
}
3234
}
3335

34-
func (s *KeyRangeManager) GetBlankKeyRanges(base *keyutil.KeyRange) []keyutil.KeyRange {
36+
// GetNonOverlappingKeyRanges returns the non-overlapping key ranges of the given base key range.
37+
func (s *KeyRangeManager) GetNonOverlappingKeyRanges(base *keyutil.KeyRange) []keyutil.KeyRange {
3538
s.Lock()
3639
defer s.Unlock()
3740
return s.sortedKeyRanges.SubtractKeyRanges(base)
3841
}
3942

43+
// Append appends the key ranges to the manager.
4044
func (s *KeyRangeManager) Append(rs []keyutil.KeyRange) {
4145
s.Lock()
4246
defer s.Unlock()
@@ -46,6 +50,7 @@ func (s *KeyRangeManager) Append(rs []keyutil.KeyRange) {
4650
s.sortedKeyRanges.SortAndDeduce()
4751
}
4852

53+
// Delete deletes the overlapping key ranges from the manager.
4954
func (s *KeyRangeManager) Delete(rs []keyutil.KeyRange) {
5055
s.Lock()
5156
defer s.Unlock()

‎pkg/schedule/schedulers/balance_leader.go

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -432,7 +432,7 @@ func (s *balanceLeaderScheduler) transferLeaderOut(solver *solver, collector *pl
432432
rs := s.conf.getRanges()
433433
if len(rs) == 1 && len(rs[0].StartKey) == 0 && len(rs[0].EndKey) == 0 {
434434
km := solver.GetKeyRangeManager()
435-
rs = km.GetBlankKeyRanges(&rs[0])
435+
rs = km.GetNonOverlappingKeyRanges(&rs[0])
436436
}
437437
solver.Region = filter.SelectOneRegion(solver.RandLeaderRegions(solver.sourceStoreID(), rs),
438438
collector, filter.NewRegionPendingFilter(), filter.NewRegionDownFilter())
@@ -481,7 +481,7 @@ func (s *balanceLeaderScheduler) transferLeaderIn(solver *solver, collector *pla
481481
rs := s.conf.getRanges()
482482
if len(rs) == 1 && len(rs[0].StartKey) == 0 && len(rs[0].EndKey) == 0 {
483483
km := solver.GetKeyRangeManager()
484-
rs = km.GetBlankKeyRanges(&rs[0])
484+
rs = km.GetNonOverlappingKeyRanges(&rs[0])
485485
}
486486
solver.Region = filter.SelectOneRegion(solver.RandFollowerRegions(solver.targetStoreID(), rs),
487487
nil, filter.NewRegionPendingFilter(), filter.NewRegionDownFilter())

‎pkg/schedule/schedulers/balance_region.go

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -140,7 +140,7 @@ func (s *balanceRegionScheduler) Schedule(cluster sche.SchedulerCluster, dryRun
140140
rs := s.conf.Ranges
141141
if len(rs) == 1 && len(rs[0].StartKey) == 0 && len(rs[0].EndKey) == 0 {
142142
km := solver.GetKeyRangeManager()
143-
rs = km.GetBlankKeyRanges(&rs[0])
143+
rs = km.GetNonOverlappingKeyRanges(&rs[0])
144144
}
145145
// sourcesStore is sorted by region score desc, so we pick the first store as source store.
146146
for sourceIndex, solver.Source = range sourceStores {

‎pkg/utils/keyutil/keyrange.go

Lines changed: 19 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -134,13 +134,27 @@ func (rs *KeyRanges) SortAndDeduce() {
134134
rs.krs = res
135135
}
136136

137-
func (rs *KeyRanges) Delete(kr *KeyRange) {
138-
for i, r := range rs.krs {
139-
if bytes.Equal(r.StartKey, kr.StartKey) && bytes.Equal(r.EndKey, kr.EndKey) {
140-
rs.krs = append(rs.krs[:i], rs.krs[i+1:]...)
141-
return
137+
// Delete deletes the KeyRange from the KeyRanges.
138+
func (rs *KeyRanges) Delete(base *KeyRange) {
139+
res := make([]*KeyRange, 0)
140+
for _, r := range rs.krs {
141+
if !r.OverLapped(base) {
142+
res = append(res, r)
143+
continue
144+
}
145+
if less(r.StartKey, base.StartKey, left) {
146+
res = append(res, &KeyRange{StartKey: r.StartKey, EndKey: MinKeyWithBoundary(r.EndKey, base.StartKey, right)})
147+
}
148+
149+
if less(base.EndKey, r.EndKey, right) {
150+
startKey := MaxKeyWithBoundary(r.StartKey, base.EndKey, right)
151+
if len(r.StartKey) == 0 {
152+
startKey = base.EndKey
153+
}
154+
res = append(res, &KeyRange{StartKey: startKey, EndKey: r.EndKey})
142155
}
143156
}
157+
rs.krs = res
144158
}
145159

146160
// SubtractKeyRanges returns the KeyRanges that are not overlapped with the given KeyRange.

‎pkg/utils/keyutil/keyrange_test.go

Lines changed: 84 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,6 @@ import (
2424

2525
func TestCodecKeyRange(t *testing.T) {
2626
re := require.New(t)
27-
2827
testCases := []struct {
2928
ks KeyRange
3029
}{
@@ -46,6 +45,7 @@ func TestCodecKeyRange(t *testing.T) {
4645
}
4746

4847
func TestOverLap(t *testing.T) {
48+
re := require.New(t)
4949
for _, tc := range []struct {
5050
name string
5151
a, b KeyRange
@@ -70,17 +70,13 @@ func TestOverLap(t *testing.T) {
7070
expect: true,
7171
},
7272
} {
73-
t.Run(tc.name, func(t *testing.T) {
74-
re := require.New(t)
75-
re.Equal(tc.expect, tc.a.OverLapped(&tc.b))
76-
re.Equal(tc.expect, tc.b.OverLapped(&tc.a))
77-
})
73+
re.Equal(tc.expect, tc.a.OverLapped(&tc.b))
74+
re.Equal(tc.expect, tc.b.OverLapped(&tc.a))
7875
}
7976
}
8077

8178
func TestMergeKeyRanges(t *testing.T) {
8279
re := require.New(t)
83-
8480
testCases := []struct {
8581
name string
8682
input []*KeyRange
@@ -151,11 +147,6 @@ func TestMergeKeyRanges(t *testing.T) {
151147
}
152148

153149
func TestSortAndDeduce(t *testing.T) {
154-
re := require.New(t)
155-
fn := func(a, b string) *KeyRange {
156-
ks := NewKeyRange(a, b)
157-
return &ks
158-
}
159150
testCases := []struct {
160151
name string
161152
input []*KeyRange
@@ -168,46 +159,39 @@ func TestSortAndDeduce(t *testing.T) {
168159
},
169160
{
170161
name: "single",
171-
input: []*KeyRange{fn("a", "b")},
172-
expect: []*KeyRange{fn("a", "b")},
162+
input: []*KeyRange{newKeyRange("a", "b")},
163+
expect: []*KeyRange{newKeyRange("a", "b")},
173164
},
174165
{
175166
name: "non-overlapping",
176-
input: []*KeyRange{fn("a", "b"), fn("c", "d")},
177-
expect: []*KeyRange{fn("a", "b"), fn("c", "d")},
167+
input: []*KeyRange{newKeyRange("a", "b"), newKeyRange("c", "d")},
168+
expect: []*KeyRange{newKeyRange("a", "b"), newKeyRange("c", "d")},
178169
},
179170
{
180171
name: "overlapping",
181-
input: []*KeyRange{fn("a", "c"), fn("b", "d")},
182-
expect: []*KeyRange{fn("a", "d")},
172+
input: []*KeyRange{newKeyRange("a", "c"), newKeyRange("b", "d")},
173+
expect: []*KeyRange{newKeyRange("a", "d")},
183174
},
184175
{
185176
name: "empty keys",
186-
input: []*KeyRange{fn("", ""), fn("a", "b")},
187-
expect: []*KeyRange{fn("", "")},
177+
input: []*KeyRange{newKeyRange("", ""), newKeyRange("a", "b")},
178+
expect: []*KeyRange{newKeyRange("", "")},
188179
},
189180
{
190181
name: "one empty key",
191-
input: []*KeyRange{fn("d", ""), fn("", "b"), fn("b", "c")},
192-
expect: []*KeyRange{fn("", "c"), fn("d", "")},
182+
input: []*KeyRange{newKeyRange("d", ""), newKeyRange("", "b"), newKeyRange("b", "c")},
183+
expect: []*KeyRange{newKeyRange("", "c"), newKeyRange("d", "")},
193184
},
194185
}
195-
186+
re := require.New(t)
196187
for _, tc := range testCases {
197-
t.Run(tc.name, func(t *testing.T) {
198-
rs := &KeyRanges{krs: tc.input}
199-
rs.SortAndDeduce()
200-
re.Equal(tc.expect, rs.Ranges(), tc.name)
201-
})
188+
rs := &KeyRanges{krs: tc.input}
189+
rs.SortAndDeduce()
190+
re.Equal(tc.expect, rs.Ranges(), tc.name)
202191
}
203192
}
204193

205194
func TestSubtractKeyRanges(t *testing.T) {
206-
re := require.New(t)
207-
fn := func(a, b string) *KeyRange {
208-
ks := NewKeyRange(a, b)
209-
return &ks
210-
}
211195
testCases := []struct {
212196
name string
213197
ks []*KeyRange
@@ -222,31 +206,82 @@ func TestSubtractKeyRanges(t *testing.T) {
222206
},
223207
{
224208
name: "single",
225-
ks: []*KeyRange{fn("a", "d"), fn("e", "f")},
209+
ks: []*KeyRange{newKeyRange("a", "d"), newKeyRange("e", "f")},
226210
base: &KeyRange{},
227-
expect: []*KeyRange{fn("", "a"), fn("d", "e"), fn("f", "")},
211+
expect: []*KeyRange{newKeyRange("", "a"), newKeyRange("d", "e"), newKeyRange("f", "")},
228212
},
229213
{
230214
name: "non-overlapping",
231-
ks: []*KeyRange{fn("a", "d"), fn("e", "f")},
232-
base: fn("g", "h"),
233-
expect: []*KeyRange{fn("g", "h")},
215+
ks: []*KeyRange{newKeyRange("a", "d"), newKeyRange("e", "f")},
216+
base: newKeyRange("g", "h"),
217+
expect: []*KeyRange{newKeyRange("g", "h")},
234218
},
235219
{
236220
name: "overlapping",
237-
ks: []*KeyRange{fn("a", "d"), fn("e", "f")},
238-
base: fn("c", "g"),
239-
expect: []*KeyRange{fn("d", "e"), fn("f", "g")},
221+
ks: []*KeyRange{newKeyRange("a", "d"), newKeyRange("e", "f")},
222+
base: newKeyRange("c", "g"),
223+
expect: []*KeyRange{newKeyRange("d", "e"), newKeyRange("f", "g")},
240224
},
241225
}
242-
226+
re := require.New(t)
243227
for _, tc := range testCases {
244-
t.Run(tc.name, func(t *testing.T) {
245-
rs := &KeyRanges{krs: tc.ks}
246-
res := rs.SubtractKeyRanges(tc.base)
247-
expectData, _ := json.Marshal(tc.expect)
248-
actualData, _ := json.Marshal(res)
249-
re.EqualValues(expectData, actualData, tc.name)
250-
})
228+
rs := &KeyRanges{krs: tc.ks}
229+
res := rs.SubtractKeyRanges(tc.base)
230+
expectData, _ := json.Marshal(tc.expect)
231+
actualData, _ := json.Marshal(res)
232+
re.EqualValues(expectData, actualData, tc.name)
251233
}
252234
}
235+
236+
func TestDeleteKeyRanges(t *testing.T) {
237+
testData := []struct {
238+
name string
239+
input []*KeyRange
240+
base *KeyRange
241+
expect []*KeyRange
242+
}{
243+
{
244+
name: "empty",
245+
input: []*KeyRange{},
246+
base: &KeyRange{},
247+
expect: []*KeyRange{},
248+
},
249+
{
250+
name: "no-overlapping",
251+
input: []*KeyRange{newKeyRange("a", "b"), newKeyRange("c", "d")},
252+
base: &KeyRange{StartKey: []byte("f"), EndKey: []byte("g")},
253+
expect: []*KeyRange{newKeyRange("a", "b"), newKeyRange("c", "d")},
254+
},
255+
{
256+
name: "overlapping",
257+
input: []*KeyRange{newKeyRange("", "c"), newKeyRange("e", "")},
258+
base: &KeyRange{StartKey: []byte("b"), EndKey: []byte("d")},
259+
expect: []*KeyRange{newKeyRange("", "b"), newKeyRange("e", "")},
260+
},
261+
{
262+
name: "between",
263+
input: []*KeyRange{newKeyRange("", "")},
264+
base: &KeyRange{StartKey: []byte("b"), EndKey: []byte("d")},
265+
expect: []*KeyRange{newKeyRange("", "b"), newKeyRange("d", "")},
266+
},
267+
{
268+
name: "equal",
269+
input: []*KeyRange{newKeyRange("", "a"), newKeyRange("b", "d")},
270+
base: &KeyRange{StartKey: []byte("b"), EndKey: []byte("d")},
271+
expect: []*KeyRange{newKeyRange("", "a")},
272+
},
273+
}
274+
re := require.New(t)
275+
for _, tc := range testData {
276+
rs := &KeyRanges{krs: tc.input}
277+
rs.Delete(tc.base)
278+
expectData, _ := json.Marshal(tc.expect)
279+
actualData, _ := json.Marshal(rs.krs)
280+
re.EqualValues(expectData, actualData, tc.name)
281+
}
282+
}
283+
284+
func newKeyRange(a, b string) *KeyRange {
285+
ks := NewKeyRange(a, b)
286+
return &ks
287+
}

‎server/cluster/cluster.go

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@ import (
3838
"github.com/pingcap/kvproto/pkg/metapb"
3939
"github.com/pingcap/kvproto/pkg/pdpb"
4040
"github.com/pingcap/log"
41+
4142
"github.com/tikv/pd/pkg/cluster"
4243
"github.com/tikv/pd/pkg/core"
4344
"github.com/tikv/pd/pkg/core/storelimit"

‎tests/integrations/mcs/scheduling/config_test.go

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,6 @@ package scheduling
1717
import (
1818
"context"
1919
"fmt"
20-
"github.com/tikv/pd/pkg/utils/keyutil"
2120
"testing"
2221
"time"
2322

0 commit comments

Comments
 (0)