*: rename and add tidb_wait_split_region_finish_backoff session var to set wait split region backoff time.

ddl/ddl_api.go

@@ -1294,7 +1294,9 @@ func (d *ddl) CreateTable(ctx sessionctx.Context, s *ast.CreateTableStmt) (err e
 		var preSplitAndScatter func()
 		// do pre-split and scatter.
 		if tbInfo.ShardRowIDBits > 0 && tbInfo.PreSplitRegions > 0 {
-			preSplitAndScatter = func() { preSplitTableRegion(d.store, tbInfo, ctx.GetSessionVars().WaitTableSplitFinish) }
+			preSplitAndScatter = func() {
+				preSplitTableShardRowIDBitsRegion(ctx, d.store, tbInfo, ctx.GetSessionVars().WaitSplitRegionFinish)
+			}
 		} else if atomic.LoadUint32(&EnableSplitTableRegion) != 0 {
 			pi := tbInfo.GetPartitionInfo()
 			if pi != nil {
@@ -1304,7 +1306,7 @@ func (d *ddl) CreateTable(ctx sessionctx.Context, s *ast.CreateTableStmt) (err e
 			}
 		}
 		if preSplitAndScatter != nil {
-			if ctx.GetSessionVars().WaitTableSplitFinish {
+			if ctx.GetSessionVars().WaitSplitRegionFinish {
 				preSplitAndScatter()
 			} else {
 				go preSplitAndScatter()

ddl/table.go

@@ -29,6 +29,7 @@ import (
 	"github.com/pingcap/tidb/kv"
 	"github.com/pingcap/tidb/meta"
 	"github.com/pingcap/tidb/meta/autoid"
+	"github.com/pingcap/tidb/sessionctx"
 	"github.com/pingcap/tidb/table"
 	"github.com/pingcap/tidb/table/tables"
 	"github.com/pingcap/tidb/tablecodec"
@@ -343,7 +344,7 @@ func checkSafePoint(w *worker, snapshotTS uint64) error {
 type splitableStore interface {
 	SplitRegion(splitKey kv.Key) error
 	SplitRegionAndScatter(splitKey kv.Key) (uint64, error)
-	WaitScatterRegionFinish(regionID uint64) error
+	WaitScatterRegionFinish(regionID uint64, backoffTime int) error
 }
 
 func splitPartitionTableRegion(store kv.Storage, pi *model.PartitionInfo) {
@@ -365,7 +366,7 @@ func splitTableRegion(store kv.Storage, tableID int64) {
 	}
 }
 
-func preSplitTableRegion(store kv.Storage, tblInfo *model.TableInfo, waitTableSplitFinish bool) {
+func preSplitTableShardRowIDBitsRegion(ctx sessionctx.Context, store kv.Storage, tblInfo *model.TableInfo, waitTableSplitFinish bool) {
 	s, ok := store.(splitableStore)
 	if !ok {
 		return
@@ -426,7 +427,7 @@ func preSplitTableRegion(store kv.Storage, tblInfo *model.TableInfo, waitTableSp
 		return
 	}
 	for _, regionID := range regionIDs {
-		err := s.WaitScatterRegionFinish(regionID)
+		err := s.WaitScatterRegionFinish(regionID, ctx.GetSessionVars().BackoffTimeVars.GetWaitScatterRegionFinishBackoff())
 		if err != nil {
 			logutil.Logger(ddlLogCtx).Warn("[ddl] wait scatter region failed", zap.Uint64("regionID", regionID), zap.Error(err))
 		}

executor/set_test.go

@@ -15,6 +15,7 @@ package executor_test
 
 import (
 	"context"
+	"strconv"
 
 	. "github.com/pingcap/check"
 	"github.com/pingcap/parser/terror"
@@ -341,12 +342,21 @@ func (s *testSuite2) TestSetVar(c *C) {
 	_, err = tk.Exec("set global read_only = abc")
 	c.Assert(err, NotNil)
 
-	// test for tidb_wait_table_split_finish
-	tk.MustQuery(`select @@session.tidb_wait_table_split_finish;`).Check(testkit.Rows("0"))
-	tk.MustExec("set tidb_wait_table_split_finish = 1")
-	tk.MustQuery(`select @@session.tidb_wait_table_split_finish;`).Check(testkit.Rows("1"))
-	tk.MustExec("set tidb_wait_table_split_finish = 0")
-	tk.MustQuery(`select @@session.tidb_wait_table_split_finish;`).Check(testkit.Rows("0"))
+	// test for tidb_wait_split_region_finish
+	tk.MustQuery(`select @@session.tidb_wait_split_region_finish;`).Check(testkit.Rows("1"))
+	tk.MustExec("set tidb_wait_split_region_finish = 1")
+	tk.MustQuery(`select @@session.tidb_wait_split_region_finish;`).Check(testkit.Rows("1"))
+	tk.MustExec("set tidb_wait_split_region_finish = 0")
+	tk.MustQuery(`select @@session.tidb_wait_split_region_finish;`).Check(testkit.Rows("0"))
+
+	// test for tidb_wait_split_region_finish_backoff
+	tk.MustQuery(`select @@session.tidb_wait_split_region_finish_backoff;`).Check(testkit.Rows(strconv.Itoa(variable.DefWaitScatterRegionFinishBackoff)))
+	tk.MustExec("set tidb_wait_split_region_finish_backoff = 1")
+	tk.MustQuery(`select @@session.tidb_wait_split_region_finish_backoff;`).Check(testkit.Rows("1"))
+	_, err = tk.Exec("set tidb_wait_split_region_finish_backoff = 0")
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, "tidb_wait_split_region_finish_backoff(0) cannot be smaller than 1")
+	tk.MustQuery(`select @@session.tidb_wait_split_region_finish_backoff;`).Check(testkit.Rows("1"))
 
 	tk.MustExec("set session tidb_back_off_weight = 3")
 	tk.MustQuery("select @@session.tidb_back_off_weight;").Check(testkit.Rows("3"))

executor/split.go

@@ -46,7 +46,7 @@ type SplitIndexRegionExec struct {
 
 type splitableStore interface {
 	SplitRegionAndScatter(splitKey kv.Key) (uint64, error)
-	WaitScatterRegionFinish(regionID uint64) error
+	WaitScatterRegionFinish(regionID uint64, backoffTime int) error
 }
 
 // Next implements the Executor Next interface.
@@ -73,11 +73,11 @@ func (e *SplitIndexRegionExec) Next(ctx context.Context, _ *chunk.RecordBatch) e
 		regionIDs = append(regionIDs, regionID)
 
 	}
-	if !e.ctx.GetSessionVars().WaitTableSplitFinish {
+	if !e.ctx.GetSessionVars().WaitSplitRegionFinish {
 		return nil
 	}
 	for _, regionID := range regionIDs {
-		err := s.WaitScatterRegionFinish(regionID)
+		err := s.WaitScatterRegionFinish(regionID, e.ctx.GetSessionVars().BackoffTimeVars.GetWaitScatterRegionFinishBackoff())
 		if err != nil {
 			logutil.Logger(context.Background()).Warn("wait scatter region failed",
 				zap.Uint64("regionID", regionID),
@@ -239,11 +239,11 @@ func (e *SplitTableRegionExec) Next(ctx context.Context, _ *chunk.RecordBatch) e
 		}
 		regionIDs = append(regionIDs, regionID)
 	}
-	if !e.ctx.GetSessionVars().WaitTableSplitFinish {
+	if !e.ctx.GetSessionVars().WaitSplitRegionFinish {
 		return nil
 	}
 	for _, regionID := range regionIDs {
-		err := s.WaitScatterRegionFinish(regionID)
+		err := s.WaitScatterRegionFinish(regionID, e.ctx.GetSessionVars().BackoffTimeVars.GetWaitScatterRegionFinishBackoff())
 		if err != nil {
 			logutil.Logger(context.Background()).Warn("wait scatter region failed",
 				zap.Uint64("regionID", regionID),

sessionctx/variable/session.go

@@ -342,8 +342,8 @@ type SessionVars struct {
 	// DDLReorgPriority is the operation priority of adding indices.
 	DDLReorgPriority int
 
-	// WaitTableSplitFinish defines the create table pre-split behaviour is sync or async.
-	WaitTableSplitFinish bool
+	// WaitSplitRegionFinish defines the split region behaviour is sync or async.
+	WaitSplitRegionFinish bool
 
 	// EnableStreaming indicates whether the coprocessor request can use streaming API.
 	// TODO: remove this after tidb-server configuration "enable-streaming' removed.
@@ -379,6 +379,9 @@ type SessionVars struct {
 
 	// LowResolutionTSO is used for reading data with low resolution TSO which is updated once every two seconds.
 	LowResolutionTSO bool
+
+	// Backoff is used for set the back off time.
+	BackoffTimeVars BackoffTimer
 }
 
 // ConnectionInfo present connection used by audit.
@@ -429,6 +432,7 @@ func NewSessionVars() *SessionVars {
 		CommandValue:                uint32(mysql.ComSleep),
 		TiDBOptJoinReorderThreshold: DefTiDBOptJoinReorderThreshold,
 		SlowQueryFile:               config.GetGlobalConfig().Log.SlowQueryFile,
+		WaitSplitRegionFinish:       DefTiDBWaitSplitRegionFinish,
 	}
 	vars.Concurrency = Concurrency{
 		IndexLookupConcurrency:     DefIndexLookupConcurrency,
@@ -792,8 +796,10 @@ func (s *SessionVars) SetSystemVar(name string, val string) error {
 		s.SlowQueryFile = val
 	case TiDBEnableFastAnalyze:
 		s.EnableFastAnalyze = TiDBOptOn(val)
-	case TiDBWaitTableSplitFinish:
-		s.WaitTableSplitFinish = TiDBOptOn(val)
+	case TiDBWaitSplitRegionFinish:
+		s.WaitSplitRegionFinish = TiDBOptOn(val)
+	case TiDBWaitSplitRegionFinishBackoff:
+		s.BackoffTimeVars.SetWaitScatterRegionFinishBackoff(tidbOptPositiveInt32(val, DefWaitScatterRegionFinishBackoff))
 	case TiDBExpensiveQueryTimeThreshold:
 		atomic.StoreUint64(&ExpensiveQueryTimeThreshold, uint64(tidbOptPositiveInt32(val, DefTiDBExpensiveQueryTimeThreshold)))
 	case TiDBTxnMode:
@@ -991,6 +997,25 @@ const (
 	SlowLogMemMax = "Mem_max"
 )
 
+type BackoffTimer struct {
+	waitScatterRegionFinish int
+}
+
+// GetWaitScatterRegionFinishBackoff gets the back off time of waitScatterRegionFinish.
+func (b *BackoffTimer) GetWaitScatterRegionFinishBackoff() int {
+	if b.waitScatterRegionFinish > 0 {
+		return b.waitScatterRegionFinish
+	}
+	return DefWaitScatterRegionFinishBackoff
+}
+
+// SetWaitScatterRegionFinishBackoff sets the back off time of waitScatterRegionFinish.
+func (b *BackoffTimer) SetWaitScatterRegionFinishBackoff(t int) {
+	if t > 0 {
+		b.waitScatterRegionFinish = t
+	}
+}
+
 // SlowLogFormat uses for formatting slow log.
 // The slow log output is like below:
 // # Time: 2019-04-28T15:24:04.309074+08:00

sessionctx/variable/sysvar.go

@@ -695,7 +695,8 @@ var defaultSysVars = []*SysVar{
 	{ScopeGlobal | ScopeSession, TiDBOptJoinReorderThreshold, strconv.Itoa(DefTiDBOptJoinReorderThreshold)},
 	{ScopeSession, TiDBCheckMb4ValueInUTF8, BoolToIntStr(config.GetGlobalConfig().CheckMb4ValueInUTF8)},
 	{ScopeSession, TiDBSlowQueryFile, ""},
-	{ScopeSession, TiDBWaitTableSplitFinish, BoolToIntStr(DefTiDBWaitTableSplitFinish)},
+	{ScopeSession, TiDBWaitSplitRegionFinish, BoolToIntStr(DefTiDBWaitSplitRegionFinish)},
+	{ScopeSession, TiDBWaitSplitRegionFinishBackoff, strconv.Itoa(DefWaitScatterRegionFinishBackoff)},
 	{ScopeSession, TiDBLowResolutionTSO, "0"},
 	{ScopeSession, TiDBExpensiveQueryTimeThreshold, strconv.Itoa(DefTiDBExpensiveQueryTimeThreshold)},
 }

sessionctx/variable/tidb_vars.go

@@ -244,8 +244,11 @@ const (
 	// It can be: PRIORITY_LOW, PRIORITY_NORMAL, PRIORITY_HIGH
 	TiDBDDLReorgPriority = "tidb_ddl_reorg_priority"
 
-	// TiDBWaitTableSplitFinish defines the create table pre-split behaviour is sync or async.
-	TiDBWaitTableSplitFinish = "tidb_wait_table_split_finish"
+	// TiDBWaitSplitRegionFinish defines the split region behaviour is sync or async.
+	TiDBWaitSplitRegionFinish = "tidb_wait_split_region_finish"
+
+	// TiDBWaitSplitRegionFinishBackoff uses to set the split and scatter region back off time.
+	TiDBWaitSplitRegionFinishBackoff = "tidb_wait_split_region_finish_backoff"
 
 	// tidb_force_priority defines the operations priority of all statements.
 	// It can be "NO_PRIORITY", "LOW_PRIORITY", "HIGH_PRIORITY", "DELAYED"
@@ -333,8 +336,9 @@ const (
 	DefTiDBDDLSlowOprThreshold         = 300
 	DefTiDBUseFastAnalyze              = false
 	DefTiDBSkipIsolationLevelCheck     = false
-	DefTiDBWaitTableSplitFinish        = false
+	DefTiDBWaitSplitRegionFinish       = true
 	DefTiDBExpensiveQueryTimeThreshold = 60 // 60s
+	DefWaitScatterRegionFinishBackoff  = 120000
 )
 
 // Process global variables.

sessionctx/variable/varsutil.go

@@ -550,6 +550,14 @@ func ValidateSetSystemVar(vars *SessionVars, name string, value string) (string,
 		if v < 0 || v >= 64 {
 			return value, errors.Errorf("tidb_join_order_algo_threshold(%d) cannot be smaller than 0 or larger than 63", v)
 		}
+	case TiDBWaitSplitRegionFinishBackoff:
+		v, err := strconv.Atoi(value)
+		if err != nil {
+			return value, ErrWrongTypeForVar.GenWithStackByArgs(name)
+		}
+		if v <= 0 {
+			return value, errors.Errorf("tidb_wait_split_region_finish_backoff(%d) cannot be smaller than 1", v)
+		}
 	}
 	return value, nil
 }

store/tikv/backoff.go

@@ -212,7 +212,6 @@ const (
 	rawkvMaxBackoff                = 20000
 	splitRegionBackoff             = 20000
 	scatterRegionBackoff           = 20000
-	waitScatterRegionFinishBackoff = 120000
 	locateRegionMaxBackoff         = 20000
 	pessimisticLockMaxBackoff      = 10000
 	pessimisticRollbackMaxBackoff  = 10000

store/tikv/split_region.go

@@ -99,10 +99,11 @@ func (s *tikvStore) scatterRegion(regionID uint64) error {
 	return nil
 }
 
-func (s *tikvStore) WaitScatterRegionFinish(regionID uint64) error {
+func (s *tikvStore) WaitScatterRegionFinish(regionID uint64, backoffTime int) error {
 	logutil.Logger(context.Background()).Info("wait scatter region",
-		zap.Uint64("regionID", regionID))
-	bo := NewBackoffer(context.Background(), waitScatterRegionFinishBackoff)
+		zap.Uint64("regionID", regionID),
+		zap.Int("backoff time", backoffTime))
+	bo := NewBackoffer(context.Background(), backoffTime)
 	logFreq := 0
 	for {
 		resp, err := s.pdClient.GetOperator(context.Background(), regionID)