Merge upstream

backup_test.go

@@ -4,7 +4,6 @@
 // license that can be found in the LICENSE file.
 
 //go:build cgo
-// +build cgo
 
 package sqlite3
 

callback.go

@@ -29,7 +29,6 @@ import (
 	"math"
 	"reflect"
 	"sync"
-	"sync/atomic"
 	"unsafe"
 )
 
@@ -104,27 +103,28 @@ type handleVal struct {
 	val any
 }
 
-var handleLock sync.Mutex
-var handleVals atomic.Value // stores map[unsafe.Pointer]handleVal
+// handleVals maps unsafe.Pointer handles to handleVal. A sync.Map keeps
+// lookups lock-free on the hot callback path while insertion and removal
+// stay O(1); the previous copy-on-write map made every registration copy
+// the whole table, so opening N connections (each registering several
+// functions) was quadratic in time and allocation.
+var handleVals sync.Map
 
 func newHandle(db *SQLiteConn, v any) unsafe.Pointer {
-	val := handleVal{db: db, val: v}
 	var p unsafe.Pointer = C.malloc(C.size_t(1))
 	if p == nil {
 		panic("can't allocate 'cgo-pointer hack index pointer': ptr == nil")
 	}
-
-	handleLock.Lock()
-	defer handleLock.Unlock()
-
-	next := cloneHandleVals(len(loadHandleVals()) + 1)
-	next[p] = val
-	handleVals.Store(next)
+	handleVals.Store(p, handleVal{db: db, val: v})
 	return p
 }
 
 func lookupHandleVal(handle unsafe.Pointer) handleVal {
-	return loadHandleVals()[handle]
+	v, ok := handleVals.Load(handle)
+	if !ok {
+		return handleVal{}
+	}
+	return v.(handleVal)
 }
 
 func lookupHandle(handle unsafe.Pointer) any {
@@ -134,55 +134,20 @@ func lookupHandle(handle unsafe.Pointer) any {
 // deleteHandle releases a single handle created by newHandle. It is a no-op
 // if the handle is unknown (e.g. already released).
 func deleteHandle(handle unsafe.Pointer) {
-	handleLock.Lock()
-	defer handleLock.Unlock()
-
-	current := loadHandleVals()
-	if _, ok := current[handle]; !ok {
-		return
+	if _, ok := handleVals.LoadAndDelete(handle); ok {
+		C.free(handle)
 	}
-	next := make(map[unsafe.Pointer]handleVal, len(current)-1)
-	for h, v := range current {
-		if h == handle {
-			continue
-		}
-		next[h] = v
-	}
-	handleVals.Store(next)
-	C.free(handle)
 }
 
 func deleteHandles(db *SQLiteConn) {
-	handleLock.Lock()
-	defer handleLock.Unlock()
-
-	current := loadHandleVals()
-	if len(current) == 0 {
-		return
-	}
-
-	next := make(map[unsafe.Pointer]handleVal, len(current))
-	for handle, val := range current {
-		if val.db == db {
-			C.free(handle)
-			continue
+	handleVals.Range(func(handle, val any) bool {
+		if val.(handleVal).db == db {
+			if _, ok := handleVals.LoadAndDelete(handle); ok {
+				C.free(handle.(unsafe.Pointer))
+			}
 		}
-		next[handle] = val
-	}
-	handleVals.Store(next)
-}
-
-func loadHandleVals() map[unsafe.Pointer]handleVal {
-	m, _ := handleVals.Load().(map[unsafe.Pointer]handleVal)
-	return m
-}
-
-func cloneHandleVals(size int) map[unsafe.Pointer]handleVal {
-	next := make(map[unsafe.Pointer]handleVal, size)
-	for handle, val := range loadHandleVals() {
-		next[handle] = val
-	}
-	return next
+		return true
+	})
 }
 
 // This is only here so that tests can refer to it.

callback_bench_test.go

@@ -4,7 +4,6 @@
 // license that can be found in the LICENSE file.
 
 //go:build cgo
-// +build cgo
 
 package sqlite3
 
@@ -49,6 +48,14 @@ func BenchmarkHandleLookupBeforeAfter(b *testing.B) {
 			return after.lookup(handle).val
 		})
 	})
+
+	var syncTable syncMapHandleTable
+	syncTable.vals.Store(handle, value)
+	b.Run("sync_map", func(b *testing.B) {
+		benchmarkHandleLookupParallel(b, func() any {
+			return syncTable.lookup(handle).val
+		})
+	})
 }
 
 func benchmarkHandleLookupParallel(b *testing.B, lookup func() any) {
@@ -75,6 +82,18 @@ func (t *mutexHandleTable) lookup(handle unsafe.Pointer) handleVal {
 	return t.vals[handle]
 }
 
+type syncMapHandleTable struct {
+	vals sync.Map
+}
+
+func (t *syncMapHandleTable) lookup(handle unsafe.Pointer) handleVal {
+	v, ok := t.vals.Load(handle)
+	if !ok {
+		return handleVal{}
+	}
+	return v.(handleVal)
+}
+
 type atomicHandleTable struct {
 	vals atomic.Value
 }

callback_test.go

@@ -4,7 +4,6 @@
 // license that can be found in the LICENSE file.
 
 //go:build cgo
-// +build cgo
 
 package sqlite3
 

convert.go

@@ -159,7 +159,7 @@ func convertAssign(dest, src any) error {
 	}
 
 	dpv := reflect.ValueOf(dest)
-	if dpv.Kind() != reflect.Ptr {
+	if dpv.Kind() != reflect.Pointer {
 		return errors.New("destination not a pointer")
 	}
 	if dpv.IsNil() {
@@ -192,7 +192,7 @@ func convertAssign(dest, src any) error {
 	// This also allows scanning into user defined types such as "type Int int64".
 	// For symmetry, also check for string destination types.
 	switch dv.Kind() {
-	case reflect.Ptr:
+	case reflect.Pointer:
 		if src == nil {
 			dv.Set(reflect.Zero(dv.Type()))
 			return nil

error_test.go

@@ -4,7 +4,6 @@
 // license that can be found in the LICENSE file.
 
 //go:build cgo
-// +build cgo
 
 package sqlite3