*: reuse chunk in the histogram

pkg/statistics/analyze.go

@@ -74,6 +74,9 @@ func (a *AnalyzeResult) DestroyAndPutToPool() {
 	for _, f := range a.Fms {
 		f.DestroyAndPutToPool()
 	}
+	for _, h := range a.Hist {
+		h.DestroyAndPutToPool()
+	}
 }
 
 // AnalyzeResults represents the analyze results of a task.

pkg/statistics/handle/storage/json.go

@@ -115,6 +115,7 @@ func GenJSONTableFromStats(sctx sessionctx.Context, dbName string, tableInfo *mo
 		}
 		jsonTbl.Columns[col.Info.Name.L] = proto
 		col.FMSketch.DestroyAndPutToPool()
+		hist.DestroyAndPutToPool()
 	}
 	for _, idx := range tbl.Indices {
 		proto := dumpJSONCol(&idx.Histogram, idx.CMSketch, idx.TopN, nil, &idx.StatsVer)

pkg/statistics/histogram.go

@@ -119,7 +119,7 @@ func NewHistogram(id, ndv, nullCount int64, version uint64, tp *types.FieldType,
 		NullCount:         nullCount,
 		LastUpdateVersion: version,
 		Tp:                tp,
-		Bounds:            chunk.NewChunkWithCapacity([]*types.FieldType{tp}, 2*bucketSize),
+		Bounds:            chunk.NewChunkFromPoolWithCapacity([]*types.FieldType{tp}, 2*bucketSize),
 		Buckets:           make([]Bucket, 0, bucketSize),
 		TotColSize:        totColSize,
 	}
@@ -220,6 +220,14 @@ func (hg *Histogram) Len() int {
 	return len(hg.Buckets)
 }
 
+// DestroyAndPutToPool resets the FMSketch and puts it to the pool.
+func (hg *Histogram) DestroyAndPutToPool() {
+	if hg == nil {
+		return
+	}
+	hg.Bounds.Destroy(len(hg.Buckets), []*types.FieldType{hg.Tp})
+}
+
 // HistogramEqual tests if two histograms are equal.
 func HistogramEqual(a, b *Histogram, ignoreID bool) bool {
 	if ignoreID {

pkg/util/chunk/BUILD.bazel

@@ -32,6 +32,7 @@ go_library(
         "//pkg/util/hack",
         "//pkg/util/logutil",
         "//pkg/util/memory",
+        "//pkg/util/syncutil",
         "@com_github_pingcap_errors//:errors",
         "@com_github_pingcap_failpoint//:failpoint",
         "@org_golang_x_sys//cpu",

pkg/util/chunk/chunk.go

@@ -71,6 +71,11 @@ func NewChunkWithCapacity(fields []*types.FieldType, capacity int) *Chunk {
 	return New(fields, capacity, capacity)
 }
 
+// NewChunkFromPoolWithCapacity creates a new chunk with field types and capacity from the pool.
+func NewChunkFromPoolWithCapacity(fields []*types.FieldType, initCap int) *Chunk {
+	return getChunkFromPool(initCap, fields)
+}
+
 // New creates a new chunk.
 //
 //	cap: the limit for the max number of rows.
@@ -669,3 +674,8 @@ func (c *Chunk) AppendPartialRows(colOff int, rows []Row) {
 		}
 	}
 }
+
+// Destroy is to destroy the Chunk and put Chunk into the pool
+func (c *Chunk) Destroy(initCap int, fields []*types.FieldType) {
+	putChunkFromPool(initCap, fields, c)
+}

pkg/util/chunk/pool.go

@@ -18,8 +18,44 @@ import (
 	"sync"
 
 	"github.com/pingcap/tidb/pkg/types"
+	"github.com/pingcap/tidb/pkg/util/syncutil"
 )
 
+var (
+	globalChunkPoolMutex syncutil.RWMutex
+	// globalChunkPool is a chunk pool, the key is the init capacity.
+	globalChunkPool = make(map[int]*Pool)
+)
+
+// getChunkFromPool gets a Chunk from the Pool. In fact, initCap is the size of the bucket in the histogram.
+// so it will not have too many difference value.
+func getChunkFromPool(initCap int, fields []*types.FieldType) *Chunk {
+	globalChunkPoolMutex.RLock()
+	pool, ok := globalChunkPool[initCap]
+	globalChunkPoolMutex.RUnlock()
+	if ok {
+		return pool.GetChunk(fields)
+	}
+	globalChunkPoolMutex.Lock()
+	defer globalChunkPoolMutex.Unlock()
+	globalChunkPool[initCap] = NewPool(initCap)
+	return globalChunkPool[initCap].GetChunk(fields)
+}
+
+func putChunkFromPool(initCap int, fields []*types.FieldType, chk *Chunk) {
+	globalChunkPoolMutex.RLock()
+	pool, ok := globalChunkPool[initCap]
+	globalChunkPoolMutex.RUnlock()
+	if ok {
+		pool.PutChunk(fields, chk)
+		return
+	}
+	globalChunkPoolMutex.Lock()
+	defer globalChunkPoolMutex.Unlock()
+	globalChunkPool[initCap] = NewPool(initCap)
+	globalChunkPool[initCap].PutChunk(fields, chk)
+}
+
 // Pool is the Column pool.
 // NOTE: Pool is non-copyable.
 type Pool struct {
@@ -36,11 +72,11 @@ type Pool struct {
 func NewPool(initCap int) *Pool {
 	return &Pool{
 		initCap:         initCap,
-		varLenColPool:   &sync.Pool{New: func() interface{} { return newVarLenColumn(initCap) }},
-		fixLenColPool4:  &sync.Pool{New: func() interface{} { return newFixedLenColumn(4, initCap) }},
-		fixLenColPool8:  &sync.Pool{New: func() interface{} { return newFixedLenColumn(8, initCap) }},
-		fixLenColPool16: &sync.Pool{New: func() interface{} { return newFixedLenColumn(16, initCap) }},
-		fixLenColPool40: &sync.Pool{New: func() interface{} { return newFixedLenColumn(40, initCap) }},
+		varLenColPool:   &sync.Pool{New: func() any { return newVarLenColumn(initCap) }},
+		fixLenColPool4:  &sync.Pool{New: func() any { return newFixedLenColumn(4, initCap) }},
+		fixLenColPool8:  &sync.Pool{New: func() any { return newFixedLenColumn(8, initCap) }},
+		fixLenColPool16: &sync.Pool{New: func() any { return newFixedLenColumn(16, initCap) }},
+		fixLenColPool40: &sync.Pool{New: func() any { return newFixedLenColumn(40, initCap) }},
 	}
 }
 
@@ -69,17 +105,19 @@ func (p *Pool) GetChunk(fields []*types.FieldType) *Chunk {
 // PutChunk puts a Chunk back to the Pool.
 func (p *Pool) PutChunk(fields []*types.FieldType, chk *Chunk) {
 	for i, f := range fields {
+		c := chk.columns[i]
+		c.reset()
 		switch elemLen := getFixedLen(f); elemLen {
 		case varElemLen:
-			p.varLenColPool.Put(chk.columns[i])
+			p.varLenColPool.Put(c)
 		case 4:
-			p.fixLenColPool4.Put(chk.columns[i])
+			p.fixLenColPool4.Put(c)
 		case 8:
-			p.fixLenColPool8.Put(chk.columns[i])
+			p.fixLenColPool8.Put(c)
 		case 16:
-			p.fixLenColPool16.Put(chk.columns[i])
+			p.fixLenColPool16.Put(c)
 		case 40:
-			p.fixLenColPool40.Put(chk.columns[i])
+			p.fixLenColPool40.Put(c)
 		}
 	}
 	chk.columns = nil // release the Column references.