Custom Windows allocator.

gormlite/go.mod

@@ -11,6 +11,6 @@ require (
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
-	github.com/tetratelabs/wazero v1.7.1 // indirect
+	github.com/tetratelabs/wazero v1.7.2 // indirect
 	golang.org/x/sys v0.20.0 // indirect
 )

gormlite/go.sum

@@ -6,8 +6,8 @@ github.com/ncruces/go-sqlite3 v0.15.0 h1:C+SIrcYsAIR5GUYWmCnif6x81n6BS9y75vYcQyn
 github.com/ncruces/go-sqlite3 v0.15.0/go.mod h1:kHHYmFmK4G2VFFoIovEg9BEQ8BP+D81y4ESHXnzJV/w=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
-github.com/tetratelabs/wazero v1.7.1 h1:QtSfd6KLc41DIMpDYlJdoMc6k7QTN246DM2+n2Y/Dx8=
-github.com/tetratelabs/wazero v1.7.1/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
+github.com/tetratelabs/wazero v1.7.2 h1:1+z5nXJNwMLPAWaTePFi49SSTL0IMx/i3Fg8Yc25GDc=
+github.com/tetratelabs/wazero v1.7.2/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
 golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=

internal/util/alloc_other.go

@@ -0,0 +1,9 @@
+//go:build !(unix || windows) || sqlite3_nosys
+
+package util
+
+import "context"
+
+func withAllocator(ctx context.Context) context.Context {
+	return ctx
+}

internal/util/alloc_unix.go

@@ -3,13 +3,22 @@
 package util
 
 import (
+	"context"
 	"math"
 
 	"github.com/tetratelabs/wazero/experimental"
 	"golang.org/x/sys/unix"
 )
 
-func mmappedAllocator(cap, max uint64) experimental.LinearMemory {
+func withAllocator(ctx context.Context) context.Context {
+	if math.MaxInt != math.MaxInt64 {
+		return ctx
+	}
+	return experimental.WithMemoryAllocator(ctx,
+		experimental.MemoryAllocatorFunc(newAllocator))
+}
+
+func newAllocator(cap, max uint64) experimental.LinearMemory {
 	// Round up to the page size.
 	rnd := uint64(unix.Getpagesize() - 1)
 	max = (max + rnd) &^ rnd

internal/util/alloc_windows.go

@@ -0,0 +1,89 @@
+//go:build !sqlite3_nosys
+
+package util
+
+import (
+	"context"
+	"math"
+	"reflect"
+	"unsafe"
+
+	"github.com/tetratelabs/wazero/experimental"
+	"golang.org/x/sys/windows"
+)
+
+func withAllocator(ctx context.Context) context.Context {
+	if math.MaxInt != math.MaxInt64 {
+		return ctx
+	}
+	return experimental.WithMemoryAllocator(ctx,
+		experimental.MemoryAllocatorFunc(newAllocator))
+}
+
+func newAllocator(cap, max uint64) experimental.LinearMemory {
+	// Round up to the page size.
+	rnd := uint64(windows.Getpagesize() - 1)
+	max = (max + rnd) &^ rnd
+	cap = (cap + rnd) &^ rnd
+
+	if max > math.MaxInt {
+		// This ensures int(max) overflows to a negative value,
+		// and unix.Mmap returns EINVAL.
+		max = math.MaxUint64
+	}
+	// Reserve max bytes of address space, to ensure we won't need to move it.
+	// A protected, private, anonymous mapping should not commit memory.
+	r, err := windows.VirtualAlloc(0, uintptr(max), windows.MEM_RESERVE, windows.PAGE_READWRITE)
+	if err != nil {
+		panic(err)
+	}
+	// Commit the initial cap bytes of memory.
+	_, err = windows.VirtualAlloc(r, uintptr(cap), windows.MEM_COMMIT, windows.PAGE_READWRITE)
+	if err != nil {
+		windows.VirtualFree(r, 0, windows.MEM_RELEASE)
+		panic(err)
+	}
+	mem := virtualMemory{addr: r}
+	// SliceHeader, although deprecated, avoids a go vet warning.
+	sh := (*reflect.SliceHeader)(unsafe.Pointer(&mem.buf))
+	sh.Len = int(cap) // Not a bug.
+	sh.Cap = int(max) // Not a bug.
+	sh.Data = r
+	return &mem
+}
+
+// The slice covers the entire mmapped memory:
+//   - len(buf) is the already committed memory,
+//   - cap(buf) is the reserved address space.
+type virtualMemory struct {
+	buf  []byte
+	addr uintptr
+}
+
+func (m *virtualMemory) Reallocate(size uint64) []byte {
+	if com := uint64(len(m.buf)); com < size {
+		// Round up to the page size.
+		rnd := uint64(windows.Getpagesize() - 1)
+		new := (size + rnd) &^ rnd
+
+		// Commit additional memory up to new bytes.
+		_, err := windows.VirtualAlloc(m.addr, uintptr(new), windows.MEM_COMMIT, windows.PAGE_READWRITE)
+		if err != nil {
+			panic(err)
+		}
+
+		// Update committed memory.
+		m.buf = m.buf[:new]
+	}
+	// Limit returned capacity because bytes beyond
+	// len(m.buf) have not yet been committed.
+	return m.buf[:size:len(m.buf)]
+}
+
+func (m *virtualMemory) Free() {
+	err := windows.VirtualFree(m.addr, 0, windows.MEM_RELEASE)
+	if err != nil {
+		panic(err)
+	}
+	m.addr = 0
+}

internal/util/mmap.go

@@ -8,15 +8,9 @@ import (
 	"unsafe"
 
 	"github.com/tetratelabs/wazero/api"
-	"github.com/tetratelabs/wazero/experimental"
 	"golang.org/x/sys/unix"
 )
 
-func withMmappedAllocator(ctx context.Context) context.Context {
-	return experimental.WithMemoryAllocator(ctx,
-		experimental.MemoryAllocatorFunc(mmappedAllocator))
-}
-
 type mmapState struct {
 	regions []*MappedRegion
 }

internal/util/mmap_other.go

@@ -2,10 +2,4 @@
 
 package util
 
-import "context"
-
 type mmapState struct{}
-
-func withMmappedAllocator(ctx context.Context) context.Context {
-	return ctx
-}

internal/util/module.go

@@ -14,7 +14,7 @@ type moduleState struct {
 
 func NewContext(ctx context.Context) context.Context {
 	state := new(moduleState)
-	ctx = withMmappedAllocator(ctx)
+	ctx = withAllocator(ctx)
 	ctx = experimental.WithCloseNotifier(ctx, state)
 	ctx = context.WithValue(ctx, moduleKey{}, state)
 	return ctx