refactor: optimize parseResult and scanResult pooling for improved me… (#51)

* refactor: optimize parseResult and scanResult pooling for improved memory efficiency and performance

* chore: fix lint error

Author: nnnkkk7

field_parser.go

@@ -23,12 +23,21 @@ type parseResult struct {
 	rows   []rowInfo   // All row information
 }
 
+// parseResultPoolFieldCap is the initial field capacity for pooled parseResult.
+// 4096 fields covers ~800 rows with 5 fields each (typical CSV).
+// fieldInfo is 12 bytes, so 4096 * 12 = ~48KB initial allocation.
+const parseResultPoolFieldCap = 4096
+
+// parseResultPoolRowCap is the initial row capacity for pooled parseResult.
+// 1024 rows with rowInfo at 24 bytes = ~24KB initial allocation.
+const parseResultPoolRowCap = 1024
+
 // parseResultPool provides reusable parseResult objects to reduce allocations
 var parseResultPool = sync.Pool{
 	New: func() interface{} {
 		return &parseResult{
-			fields: make([]fieldInfo, 0, 512), // Smaller initial (6KB)
-			rows:   make([]rowInfo, 0, 128),   // Smaller initial (1.5KB)
+			fields: make([]fieldInfo, 0, parseResultPoolFieldCap),
+			rows:   make([]rowInfo, 0, parseResultPoolRowCap),
 		}
 	},
 }

quote.go

@@ -158,14 +158,17 @@ func unescapeDoubleQuotesScalar(s string) string {
 
 // unescapeDoubleQuotesSIMD uses SIMD to find double quotes and unescape them.
 func unescapeDoubleQuotesSIMD(s string) string {
+	if len(s) < simdChunkSize {
+		return unescapeDoubleQuotesScalar(s)
+	}
 	data := unsafe.Slice(unsafe.StringData(s), len(s))
-	quoteCmp := archsimd.BroadcastInt8x32('"')
+	quoteCmp := archsimd.BroadcastInt8x64('"')
 	var result []byte
 	lastWritten := 0
 	skipNextQuote := false
 	i := 0
-	for i+32 <= len(data) {
-		chunk := archsimd.LoadInt8x32((*[32]int8)(unsafe.Pointer(&data[i])))
+	for i+simdChunkSize <= len(data) {
+		chunk := archsimd.LoadInt8x64((*[simdChunkSize]int8)(unsafe.Pointer(&data[i])))
 		mask := chunk.Equal(quoteCmp).ToBits()
 
 		if skipNextQuote {
@@ -177,7 +180,7 @@ func unescapeDoubleQuotesSIMD(s string) string {
 
 		if mask != 0 {
 			for mask != 0 {
-				pos := bits.TrailingZeros32(mask)
+				pos := bits.TrailingZeros64(mask)
 				absPos := i + pos
 
 				if absPos+1 < len(data) && data[absPos+1] == '"' {
@@ -188,18 +191,18 @@ func unescapeDoubleQuotesSIMD(s string) string {
 					result = append(result, s[lastWritten:absPos+1]...)
 					lastWritten = absPos + 2 // Skip the second quote
 					// Clear both bits if second quote is in same chunk
-					mask &= ^(uint32(1) << pos)
-					if pos+1 < 32 {
-						mask &= ^(uint32(1) << (pos + 1))
+					mask &^= uint64(1) << pos
+					if pos+1 < simdChunkSize {
+						mask &^= uint64(1) << (pos + 1)
 					} else {
 						skipNextQuote = true
 					}
 					continue
 				}
-				mask &= ^(uint32(1) << pos)
+				mask &^= uint64(1) << pos
 			}
 		}
-		i += 32
+		i += simdChunkSize
 	}
 
 	// Process remaining bytes

simd_scanner.go

@@ -105,9 +105,10 @@ type scanResult struct {
 }
 
 // scanResultPoolCapacity is the pre-allocated slice capacity for pooled scanResult objects.
-// 256 chunks = ~16KB input (256 * 64 bytes per chunk) - covers most typical CSV files.
-// Increased from 64 to reduce ensureUint64SliceCap reallocations observed in profiling.
-const scanResultPoolCapacity = 256
+// 2048 chunks = ~128KB input (2048 * 64 bytes per chunk) - covers most typical CSV files.
+// Increased from 256 to reduce ensureUint64SliceCap reallocations observed in profiling.
+// For 10K-row CSV (~600KB), this covers ~13% with initial capacity, reducing reallocs.
+const scanResultPoolCapacity = 2048
 
 // scanResultPool provides reusable scanResult objects to reduce allocations.
 var scanResultPool = sync.Pool{
@@ -153,14 +154,20 @@ func releaseScanResult(sr *scanResult) {
 
 // ensureUint64SliceCap ensures slice has at least required length with 2x growth.
 // Returns the slice with length set to required.
+// Note: This creates a new slice if capacity is insufficient; the old slice's
+// capacity is lost but this is acceptable since pooled objects start with
+// sufficient capacity (scanResultPoolCapacity) for most use cases.
 func ensureUint64SliceCap(s []uint64, required int) []uint64 {
 	if cap(s) >= required {
 		return s[:required]
 	}
+	// Use max of 2x growth or required capacity
 	newCap := cap(s) * 2
 	if newCap < required {
 		newCap = required
 	}
+	// Add 25% headroom to reduce future reallocations
+	newCap += newCap / 4
 	return make([]uint64, required, newCap)
 }
 
@@ -172,10 +179,13 @@ func ensureBoolSliceCap(s []bool, required int) []bool {
 		clear(s)
 		return s
 	}
+	// Use max of 2x growth or required capacity
 	newCap := cap(s) * 2
 	if newCap < required {
 		newCap = required
 	}
+	// Add 25% headroom to reduce future reallocations
+	newCap += newCap / 4
 	return make([]bool, required, newCap)
 }