Resolve conflict.

Author: OliverS929

pkg/lightning/backend/local/localhelper.go

@@ -35,21 +35,11 @@ import (
 	"golang.org/x/time/rate"
 )
 
-<<<<<<< HEAD
-=======
 // 64 is chosen based on nextgen import shape: subtask size is ~100 GiB and each region is ~1 GiB,
 // so split key count is often around 100. A threshold of 100 may miss coarse split/scatter on boundary
 // cases, while 64 triggers early load spreading and still avoids this stage for smaller tasks.
 const coarseGrainedSplitKeysThreshold = 64
 
-var (
-
-	// the base exponential backoff time
-	// the variable is only changed in unit test for running test faster.
-	splitRegionBaseBackOffTime = time.Second
-)
-
->>>>>>> 4ffecda589a (lightning: restore two-level split/scatter while keeping limiter behavior (#66312))
 // splitAndScatterRegionInBatches splits&scatter regions in batches.
 // Too many split&scatter requests may put a lot of pressure on TiKV and PD.
 func (local *Backend) splitAndScatterRegionInBatches(

pkg/lightning/backend/local/localhelper_test.go

@@ -44,6 +44,67 @@ type testSplitClient struct {
 	splitCount           atomic.Int32
 	splitKeysAndScatterF func(context.Context, [][]byte, int32) ([]*split.RegionInfo, error)
 	hook                 clientHook
+func TestSplitAndScatterRegionInBatchesTwoLevel(t *testing.T) {
+	makeSplitKeys := func(n int) [][]byte {
+		keys := make([][]byte, n)
+		for i := 0; i < n; i++ {
+			keys[i] = []byte{byte(i >> 8), byte(i)}
+		}
+		return keys
+	}
+
+	t.Run("large split keys trigger coarse and fine layers", func(t *testing.T) {
+		splitCli := &testSplitClient{}
+		local := &Backend{splitCli: splitCli}
+
+		err := local.splitAndScatterRegionInBatches(context.Background(), makeSplitKeys(121), 50, 0)
+		require.NoError(t, err)
+		// 121 keys => coarse pass(11 keys, 1 batch) + fine pass(121 keys, 3 batches) = 4 calls.
+		require.Equal(t, int32(4), splitCli.splitCount.Load())
+	})
+
+	t.Run("small split keys only use fine layer", func(t *testing.T) {
+		splitCli := &testSplitClient{}
+		local := &Backend{splitCli: splitCli}
+
+		err := local.splitAndScatterRegionInBatches(context.Background(), makeSplitKeys(coarseGrainedSplitKeysThreshold), 50, 0)
+		require.NoError(t, err)
+		require.Equal(t, int32(2), splitCli.splitCount.Load())
+	})
+
+	t.Run("coarse layer error returns immediately", func(t *testing.T) {
+		splitCli := &testSplitClient{
+			splitKeysAndScatterF: func(_ context.Context, _ [][]byte, splitCnt int32) ([]*split.RegionInfo, error) {
+				if splitCnt == 1 {
+					return nil, errors.New("mock split error")
+				}
+				return []*split.RegionInfo{
+					{
+						Region: &metapb.Region{Id: 1},
+					},
+				}, nil
+			},
+		}
+		local := &Backend{splitCli: splitCli}
+
+		err := local.splitAndScatterRegionInBatches(context.Background(), makeSplitKeys(121), 50, 0)
+		require.ErrorContains(t, err, "mock split error")
+		require.Equal(t, int32(1), splitCli.splitCount.Load())
+	})
+
+	t.Run("limiter is still enforced after restoring two levels", func(t *testing.T) {
+		splitCli := &testSplitClient{}
+		local := &Backend{splitCli: splitCli}
+		ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+		defer cancel()
+
+		// maxCntPerSec=0.5 => burstPerSec=1, so after first batch, limiter blocks
+		// and should hit context deadline before entering fine-grained stage.
+		err := local.splitAndScatterRegionInBatches(ctx, makeSplitKeys(121), 50, 0.5)
+		require.ErrorContains(t, err, "context deadline")
+		require.Equal(t, int32(1), splitCli.splitCount.Load())
+	})
+}
 }
 
 func newTestSplitClient(
@@ -340,7 +401,6 @@ func TestStoreWriteLimiter(t *testing.T) {
 	wg.Wait()
 }
 
-<<<<<<< HEAD
 func TestTuneStoreWriteLimiter(t *testing.T) {
 	limiter := newStoreWriteLimiter(100)
 	testLimiter := func(ctx context.Context, maxT int) {
@@ -462,5 +522,4 @@ func TestGetCoarseGrainedSplitKeys(t *testing.T) {
 
 		require.Equal(t, 1, lastKeyCount)
 	})
->>>>>>> 4ffecda589a (lightning: restore two-level split/scatter while keeping limiter behavior (#66312))
 }