refactor: enhance record parsing efficiency by introducing no-quote path and optimizing memory usage (#63)

Author: nnnkkk7

parse.go

@@ -3,6 +3,8 @@
 //nolint:gosec // G115: Integer conversions are safe - buffer size bounded by DefaultMaxInputSize (2GB)
 package simdcsv
 
+import "unsafe"
+
 // ============================================================================
 // Public API - Direct Parsing
 // ============================================================================
@@ -65,12 +67,12 @@ func buildRecords(buf []byte, pr *parseResult, hasCR bool) [][]string {
 
 	records := make([][]string, len(pr.rows))
 
-	// Shared buffers reused across records
-	var recordBuf []byte
+	// fieldEnds can be reused, but recordBuf must be unique per record for unsafe.String
 	var fieldEnds []int
 
 	for i, row := range pr.rows {
-		recordBuf, fieldEnds = accumulateFields(buf, pr, row, hasCR, recordBuf[:0], fieldEnds[:0])
+		var recordBuf []byte
+		recordBuf, fieldEnds = accumulateFields(buf, pr, row, hasCR, recordBuf, fieldEnds[:0])
 		records[i] = sliceFieldsFromBuffer(recordBuf, fieldEnds)
 	}
 	return records
@@ -97,9 +99,13 @@ func accumulateFields(buf []byte, pr *parseResult, row rowInfo, hasCR bool, reco
 }
 
 // sliceFieldsFromBuffer converts the accumulated buffer to individual field strings.
-// Uses a single string conversion followed by zero-copy slicing.
+// Uses unsafe.String for zero-copy conversion. Caller must ensure recordBuf is not reused.
 func sliceFieldsFromBuffer(recordBuf []byte, fieldEnds []int) []string {
-	str := string(recordBuf)
+	if len(recordBuf) == 0 {
+		return make([]string, len(fieldEnds))
+	}
+	// Zero-copy string conversion - safe because recordBuf is unique per record
+	str := unsafe.String(unsafe.SliceData(recordBuf), len(recordBuf))
 	record := make([]string, len(fieldEnds))
 	prevEnd := 0
 	for i, end := range fieldEnds {

quote.go

@@ -4,7 +4,6 @@ package simdcsv
 
 import (
 	"math/bits"
-	"unsafe"
 
 	"simd/archsimd"
 )
@@ -99,10 +98,11 @@ func findClosingQuoteScalar(data []byte, startAfterOpenQuote int) int {
 // findClosingQuoteSIMD uses AVX-512 to find the closing quote in simdHalfChunk-byte chunks.
 func findClosingQuoteSIMD(data []byte, startAfterOpenQuote int) int {
 	quoteCmp := archsimd.BroadcastInt8x32('"')
+	int8Data := bytesToInt8Slice(data)
 	i := startAfterOpenQuote
 
 	for i+simdHalfChunk <= len(data) {
-		chunk := archsimd.LoadInt8x32((*[simdHalfChunk]int8)(unsafe.Pointer(&data[i])))
+		chunk := archsimd.LoadInt8x32Slice(int8Data[i : i+simdHalfChunk])
 		mask := chunk.Equal(quoteCmp).ToBits()
 
 		if mask == 0 {

reader.go

@@ -252,6 +252,16 @@ func (r *Reader) readNextRecord() ([]string, error) {
 			continue
 		}
 
+		// Fast path: no quotes anywhere, so no unescape/validation needed.
+		if !r.state.hasQuotes {
+			record := r.buildRecordNoQuotes(rowInfo)
+			if err := r.validateFieldCount(record, rowInfo); err != nil {
+				return record, err
+			}
+			r.state.nonCommentRecordCount++
+			return record, nil
+		}
+
 		record, err := r.buildRecordWithValidation(rowInfo, rowIdx)
 		if err != nil {
 			return record, err

record_builder.go

@@ -45,6 +45,40 @@ func (r *Reader) buildRecordWithValidation(row rowInfo, rowIdx int) ([]string, e
 	return r.buildFinalRecord(fieldCount), nil
 }
 
+// buildRecordNoQuotes builds a record when the input contains no quotes.
+// It avoids the recordBuffer copy path and mirrors appendSimpleContent behavior.
+func (r *Reader) buildRecordNoQuotes(row rowInfo) []string {
+	fieldCount := row.fieldCount
+	record := r.allocateRecord(fieldCount)
+	r.state.fieldPositions = r.ensureFieldPositionsCapacity(fieldCount)
+
+	fields := r.getFieldsForRow(row, fieldCount)
+	buf := r.state.rawBuffer
+	bufLen := uint32(len(buf))
+
+	for i, field := range fields {
+		start := field.start
+		end := start + field.length
+		if start >= bufLen {
+			record[i] = ""
+			r.state.fieldPositions[i] = position{line: row.lineNum, column: int(start) + 1}
+			continue
+		}
+		if end > bufLen {
+			end = bufLen
+		}
+
+		content := buf[start:end]
+		if r.TrimLeadingSpace {
+			content = trimLeftBytes(content)
+		}
+
+		record[i] = string(content)
+		r.state.fieldPositions[i] = position{line: row.lineNum, column: int(start) + 1}
+	}
+	return record
+}
+
 // getFieldsForRow extracts the slice of fieldInfo for the given row.
 func (r *Reader) getFieldsForRow(row rowInfo, fieldCount int) []fieldInfo {
 	endIdx := row.firstField + fieldCount

simd_scanner.go

@@ -9,6 +9,15 @@ import (
 	"unsafe"
 )
 
+// bytesToInt8Slice converts a byte slice to an int8 slice without copying.
+// This enables use of LoadInt8xNSlice functions which are safer than pointer casts.
+func bytesToInt8Slice(b []byte) []int8 {
+	if len(b) == 0 {
+		return nil
+	}
+	return unsafe.Slice((*int8)(unsafe.Pointer(unsafe.SliceData(b))), len(b))
+}
+
 // useAVX512 indicates whether AVX-512 instructions are available at runtime.
 var useAVX512 bool
 
@@ -177,7 +186,7 @@ func generateMasksAVX512(data []byte, separator byte) (quote, sep, cr, nl uint64
 
 // generateMasksAVX512WithCmp generates masks reusing pre-broadcasted comparators.
 func generateMasksAVX512WithCmp(data []byte, quoteCmp, sepCmp, crCmp, nlCmp archsimd.Int8x64) (quote, sep, cr, nl uint64) {
-	chunk := archsimd.LoadInt8x64((*[simdChunkSize]int8)(unsafe.Pointer(&data[0])))
+	chunk := archsimd.LoadInt8x64Slice(bytesToInt8Slice(data))
 	return chunk.Equal(quoteCmp).ToBits(),
 		chunk.Equal(sepCmp).ToBits(),
 		chunk.Equal(crCmp).ToBits(),
@@ -222,17 +231,21 @@ func generateMasksPadded(data []byte, separator byte) (quote, sep, cr, nl uint64
 }
 
 // generateMasksPaddedWithCmp is the AVX-512 version of generateMasksPadded.
+// Uses LoadInt8x64SlicePart to safely load partial chunks without manual padding.
 func generateMasksPaddedWithCmp(data []byte, quoteCmp, sepCmp, crCmp, nlCmp archsimd.Int8x64) (quote, sep, cr, nl uint64, validBits int) {
 	validBits = len(data)
 	if validBits == 0 {
 		return 0, 0, 0, 0, 0
 	}
 
-	var padded [simdChunkSize]byte
-	copy(padded[:], data)
-
-	quote, sep, cr, nl = generateMasksAVX512WithCmp(padded[:], quoteCmp, sepCmp, crCmp, nlCmp)
+	// SlicePart safely loads partial data, zero-filling unused lanes
+	chunk := archsimd.LoadInt8x64SlicePart(bytesToInt8Slice(data))
+	quote = chunk.Equal(quoteCmp).ToBits()
+	sep = chunk.Equal(sepCmp).ToBits()
+	cr = chunk.Equal(crCmp).ToBits()
+	nl = chunk.Equal(nlCmp).ToBits()
 
+	// Mask out bits beyond valid data
 	if validBits < simdChunkSize {
 		mask := (uint64(1) << validBits) - 1
 		quote &= mask

writer.go

@@ -125,6 +125,7 @@ func (w *Writer) fieldNeedsQuotesScalar(field string) bool {
 // fieldNeedsQuotesSIMD uses SIMD to detect special characters requiring quoting.
 func (w *Writer) fieldNeedsQuotesSIMD(field string) bool {
 	data := unsafe.Slice(unsafe.StringData(field), len(field))
+	int8Data := bytesToInt8Slice(data)
 
 	commaCmp := archsimd.BroadcastInt8x32(int8(w.Comma))
 	newlineCmp := archsimd.BroadcastInt8x32('\n')
@@ -134,7 +135,7 @@ func (w *Writer) fieldNeedsQuotesSIMD(field string) bool {
 	// Process 32-byte chunks
 	offset := 0
 	for offset+32 <= len(data) {
-		chunk := archsimd.LoadInt8x32((*[32]int8)(unsafe.Pointer(&data[offset])))
+		chunk := archsimd.LoadInt8x32Slice(int8Data[offset : offset+32])
 
 		commaMask := chunk.Equal(commaCmp).ToBits()
 		newlineMask := chunk.Equal(newlineCmp).ToBits()
@@ -147,7 +148,7 @@ func (w *Writer) fieldNeedsQuotesSIMD(field string) bool {
 		offset += 32
 	}
 
-	// Process remaining bytes
+	// Process remaining bytes (< 32 bytes, scalar is sufficient)
 	for ; offset < len(data); offset++ {
 		c := data[offset]
 		if c == byte(w.Comma) || c == '\n' || c == '\r' || c == '"' {
@@ -187,14 +188,15 @@ func (w *Writer) writeQuotedFieldScalar(field string) error {
 // writeQuotedFieldSIMD escapes quotes using SIMD to find quote positions.
 func (w *Writer) writeQuotedFieldSIMD(field string) error {
 	data := unsafe.Slice(unsafe.StringData(field), len(field))
+	int8Data := bytesToInt8Slice(data)
 	quoteCmp := archsimd.BroadcastInt8x32('"')
 
 	offset := 0
 	lastWritten := 0
 
 	// Process 32-byte chunks
 	for offset+32 <= len(data) {
-		chunk := archsimd.LoadInt8x32((*[32]int8)(unsafe.Pointer(&data[offset])))
+		chunk := archsimd.LoadInt8x32Slice(int8Data[offset : offset+32])
 		mask := chunk.Equal(quoteCmp).ToBits()
 
 		for mask != 0 {
@@ -215,7 +217,7 @@ func (w *Writer) writeQuotedFieldSIMD(field string) error {
 		offset += 32
 	}
 
-	// Process remaining bytes
+	// Process remaining bytes (< 32 bytes, scalar is sufficient)
 	for ; offset < len(data); offset++ {
 		if data[offset] == '"' {
 			if _, err := w.w.WriteString(field[lastWritten : offset+1]); err != nil {