all: improve memory usage (#282)

Don't allocate when being called by objc.Send. This is done by just inlining the expansion of the parameters directly into the argument list instead of making a tmp slice.

Use a sync.Pool for syscall15Args struct to save on allocations

commit: 0196f2d3cc8275725fe6476b32409caa244b1a8a
author: TotallyGamerJet · 2y ago · 2024-10-18 02:31 UTC
committer: GitHub · 2y ago · 2024-10-18 02:31 UTC
parent: 7402fed
signature: GPG UnverifiedB5690EEEBB952194 The key is unknown

1 file · +59 -45

M func.go +59 -45


@@ -10,11 +10,16 @@ import (
10	10		"math"
11	11		"reflect"
12	12		"runtime"
	13	+	"sync"
13	14		"unsafe"
14	15
15	16		"github.com/ebitengine/purego/internal/strings"
16	17		)
17	18
	19	+	var thePool = sync.Pool{New: func() any {
	20	+	return new(syscall15Args)
	21	+	}}
	22	+
18	23		// RegisterLibFunc is a wrapper around RegisterFunc that uses the C function returned from Dlsym(handle, name).
19	24		// It panics if it can't find the name symbol.
20	25		func RegisterLibFunc(fptr interface{}, handle uintptr, name string) {

@@ -200,18 +205,6 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
200	205		}
201	206		}
202	207		v := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) {
203		-	if len(args) > 0 {
204		-	if variadic, ok := args[len(args)-1].Interface().([]interface{}); ok {
205		-	// subtract one from args bc the last argument in args is []interface{}
206		-	// which we are currently expanding
207		-	tmp := make([]reflect.Value, len(args)-1+len(variadic))
208		-	n := copy(tmp, args[:len(args)-1])
209		-	for i, v := range variadic {
210		-	tmp[n+i] = reflect.ValueOf(v)
211		-	}
212		-	args = tmp
213		-	}
214		-	}
215	208		var sysargs [maxArgs]uintptr
216	209		stack := sysargs[numOfIntegerRegisters():]
217	210		var floats [numOfFloats]uintptr

@@ -260,7 +253,8 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
260	253		runtime.KeepAlive(keepAlive)
261	254		runtime.KeepAlive(args)
262	255		}()
263		-	var syscall syscall15Args
	256	+	syscall := thePool.Get().(*syscall15Args)
	257	+	defer thePool.Put(syscall)
264	258		if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct {
265	259		outType := ty.Out(0)
266	260		if runtime.GOARCH == "amd64" && outType.Size() > maxRegAllocStructSize {

@@ -276,40 +270,21 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
276	270		}
277	271		}
278	272		}
279		-	for _, v := range args {
280		-	switch v.Kind() {
281		-	case reflect.String:
282		-	ptr := strings.CString(v.String())
283		-	keepAlive = append(keepAlive, ptr)
284		-	addInt(uintptr(unsafe.Pointer(ptr)))
285		-	case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
286		-	addInt(uintptr(v.Uint()))
287		-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
288		-	addInt(uintptr(v.Int()))
289		-	case reflect.Ptr, reflect.UnsafePointer, reflect.Slice:
290		-	// There is no need to keepAlive this pointer separately because it is kept alive in the args variable
291		-	addInt(v.Pointer())
292		-	case reflect.Func:
293		-	addInt(NewCallback(v.Interface()))
294		-	case reflect.Bool:
295		-	if v.Bool() {
296		-	addInt(1)
297		-	} else {
298		-	addInt(0)
	273	+	for i, v := range args {
	274	+	if variadic, ok := args[i].Interface().([]interface{}); ok {
	275	+	if i != len(args)-1 {
	276	+	panic("purego: can only expand last parameter")
299	277		}
300		-	case reflect.Float32:
301		-	addFloat(uintptr(math.Float32bits(float32(v.Float()))))
302		-	case reflect.Float64:
303		-	addFloat(uintptr(math.Float64bits(v.Float())))
304		-	case reflect.Struct:
305		-	keepAlive = addStruct(v, &numInts, &numFloats, &numStack, addInt, addFloat, addStack, keepAlive)
306		-	default:
307		-	panic("purego: unsupported kind: " + v.Kind().String())
	278	+	for _, x := range variadic {
	279	+	keepAlive = addValue(reflect.ValueOf(x), keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack)
	280	+	}
	281	+	continue
308	282		}
	283	+	keepAlive = addValue(v, keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack)
309	284		}
310	285		if runtime.GOARCH == "arm64" \|\| runtime.GOOS != "windows" {
311	286		// Use the normal arm64 calling convention even on Windows
312		-	syscall = syscall15Args{
	287	+	*syscall = syscall15Args{
313	288		cfn,
314	289		sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5],
315	290		sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11],

@@ -317,7 +292,7 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
317	292		floats[0], floats[1], floats[2], floats[3], floats[4], floats[5], floats[6], floats[7],
318	293		syscall.arm64_r8,
319	294		}
320		-	runtime_cgocall(syscall15XABI0, unsafe.Pointer(&syscall))
	295	+	runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall))
321	296		} else {
322	297		// This is a fallback for Windows amd64, 386, and arm. Note this may not support floats
323	298		syscall.a1, syscall.a2, _ = syscall_syscall15X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4],

@@ -357,15 +332,54 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
357	332		// On 32bit platforms syscall.r2 is the upper part of a 64bit return.
358	333		v.SetFloat(math.Float64frombits(uint64(syscall.f1)))
359	334		case reflect.Struct:
360		-	v = getStruct(outType, syscall)
	335	+	v = getStruct(outType, *syscall)
361	336		default:
362	337		panic("purego: unsupported return kind: " + outType.Kind().String())
363	338		}
364		-	return []reflect.Value{v}
	339	+	if len(args) > 0 {
	340	+	// reuse args slice instead of allocating one when possible
	341	+	args[0] = v
	342	+	return args[:1]
	343	+	} else {
	344	+	return []reflect.Value{v}
	345	+	}
365	346		})
366	347		fn.Set(v)
367	348		}
368	349
	350	+	func addValue(v reflect.Value, keepAlive []interface{}, addInt func(x uintptr), addFloat func(x uintptr), addStack func(x uintptr), numInts int, numFloats int, numStack *int) []interface{} {
	351	+	switch v.Kind() {
	352	+	case reflect.String:
	353	+	ptr := strings.CString(v.String())
	354	+	keepAlive = append(keepAlive, ptr)
	355	+	addInt(uintptr(unsafe.Pointer(ptr)))
	356	+	case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
	357	+	addInt(uintptr(v.Uint()))
	358	+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
	359	+	addInt(uintptr(v.Int()))
	360	+	case reflect.Ptr, reflect.UnsafePointer, reflect.Slice:
	361	+	// There is no need to keepAlive this pointer separately because it is kept alive in the args variable
	362	+	addInt(v.Pointer())
	363	+	case reflect.Func:
	364	+	addInt(NewCallback(v.Interface()))
	365	+	case reflect.Bool:
	366	+	if v.Bool() {
	367	+	addInt(1)
	368	+	} else {
	369	+	addInt(0)
	370	+	}
	371	+	case reflect.Float32:
	372	+	addFloat(uintptr(math.Float32bits(float32(v.Float()))))
	373	+	case reflect.Float64:
	374	+	addFloat(uintptr(math.Float64bits(v.Float())))
	375	+	case reflect.Struct:
	376	+	keepAlive = addStruct(v, numInts, numFloats, numStack, addInt, addFloat, addStack, keepAlive)
	377	+	default:
	378	+	panic("purego: unsupported kind: " + v.Kind().String())
	379	+	}
	380	+	return keepAlive
	381	+	}
	382	+
369	383		// maxRegAllocStructSize is the biggest a struct can be while still fitting in registers.
370	384		// if it is bigger than this than enough space must be allocated on the heap and then passed into
371	385		// the function as the first parameter on amd64 or in R8 on arm64.

 	"math"
 	"reflect"
 	"runtime"
+	"sync"
 	"unsafe"
 	"github.com/ebitengine/purego/internal/strings"
 )
+var thePool = sync.Pool{New: func() any {
+	return new(syscall15Args)
+}}
 // RegisterLibFunc is a wrapper around RegisterFunc that uses the C function returned from Dlsym(handle, name).
 // It panics if it can't find the name symbol.
 func RegisterLibFunc(fptr interface{}, handle uintptr, name string) {
 		}
 	}
 	v := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) {
-		if len(args) > 0 {
-			if variadic, ok := args[len(args)-1].Interface().([]interface{}); ok {
-				// subtract one from args bc the last argument in args is []interface{}
-				// which we are currently expanding
-				tmp := make([]reflect.Value, len(args)-1+len(variadic))
-				n := copy(tmp, args[:len(args)-1])
-				for i, v := range variadic {
-					tmp[n+i] = reflect.ValueOf(v)
-				}
-				args = tmp
-			}
-		}
 		var sysargs [maxArgs]uintptr
 		stack := sysargs[numOfIntegerRegisters():]
 		var floats [numOfFloats]uintptr
 			runtime.KeepAlive(keepAlive)
 			runtime.KeepAlive(args)
 		}()
-		var syscall syscall15Args
+		syscall := thePool.Get().(*syscall15Args)
+		defer thePool.Put(syscall)
 		if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct {
 			outType := ty.Out(0)
 			if runtime.GOARCH == "amd64" && outType.Size() > maxRegAllocStructSize {
 				}
 			}
 		}
-		for _, v := range args {
+		for i, v := range args {
-			switch v.Kind() {
+			if variadic, ok := args[i].Interface().([]interface{}); ok {
-			case reflect.String:
+				if i != len(args)-1 {
-				ptr := strings.CString(v.String())
+					panic("purego: can only expand last parameter")
-				keepAlive = append(keepAlive, ptr)
-				addInt(uintptr(unsafe.Pointer(ptr)))
-			case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-				addInt(uintptr(v.Uint()))
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				addInt(uintptr(v.Int()))
-			case reflect.Ptr, reflect.UnsafePointer, reflect.Slice:
-				// There is no need to keepAlive this pointer separately because it is kept alive in the args variable
-				addInt(v.Pointer())
-			case reflect.Func:
-				addInt(NewCallback(v.Interface()))
-			case reflect.Bool:
-				if v.Bool() {
-					addInt(1)
-				} else {
-					addInt(0)
 				}
-			case reflect.Float32:
+				for _, x := range variadic {
-				addFloat(uintptr(math.Float32bits(float32(v.Float()))))
+					keepAlive = addValue(reflect.ValueOf(x), keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack)
-			case reflect.Float64:
+				}
-				addFloat(uintptr(math.Float64bits(v.Float())))
+				continue
-			case reflect.Struct:
-				keepAlive = addStruct(v, &numInts, &numFloats, &numStack, addInt, addFloat, addStack, keepAlive)
-			default:
-				panic("purego: unsupported kind: " + v.Kind().String())
 			}
+			keepAlive = addValue(v, keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack)
 		}
 		if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" {
 			// Use the normal arm64 calling convention even on Windows
-			syscall = syscall15Args{
+			*syscall = syscall15Args{
 				cfn,
 				sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5],
 				sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11],
 				floats[0], floats[1], floats[2], floats[3], floats[4], floats[5], floats[6], floats[7],
 				syscall.arm64_r8,
 			}
-			runtime_cgocall(syscall15XABI0, unsafe.Pointer(&syscall))
+			runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall))
 		} else {
 			// This is a fallback for Windows amd64, 386, and arm. Note this may not support floats
 			syscall.a1, syscall.a2, _ = syscall_syscall15X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4],
 			// On 32bit platforms syscall.r2 is the upper part of a 64bit return.
 			v.SetFloat(math.Float64frombits(uint64(syscall.f1)))
 		case reflect.Struct:
-			v = getStruct(outType, syscall)
+			v = getStruct(outType, *syscall)
 		default:
 			panic("purego: unsupported return kind: " + outType.Kind().String())
 		}
-		return []reflect.Value{v}
+		if len(args) > 0 {
+			// reuse args slice instead of allocating one when possible
+			args[0] = v
+			return args[:1]
+		} else {
+			return []reflect.Value{v}
+		}
 	})
 	fn.Set(v)
 }
+func addValue(v reflect.Value, keepAlive []interface{}, addInt func(x uintptr), addFloat func(x uintptr), addStack func(x uintptr), numInts *int, numFloats *int, numStack *int) []interface{} {
+	switch v.Kind() {
+	case reflect.String:
+		ptr := strings.CString(v.String())
+		keepAlive = append(keepAlive, ptr)
+		addInt(uintptr(unsafe.Pointer(ptr)))
+	case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		addInt(uintptr(v.Uint()))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		addInt(uintptr(v.Int()))
+	case reflect.Ptr, reflect.UnsafePointer, reflect.Slice:
+		// There is no need to keepAlive this pointer separately because it is kept alive in the args variable
+		addInt(v.Pointer())
+	case reflect.Func:
+		addInt(NewCallback(v.Interface()))
+	case reflect.Bool:
+		if v.Bool() {
+			addInt(1)
+		} else {
+			addInt(0)
+		}
+	case reflect.Float32:
+		addFloat(uintptr(math.Float32bits(float32(v.Float()))))
+	case reflect.Float64:
+		addFloat(uintptr(math.Float64bits(v.Float())))
+	case reflect.Struct:
+		keepAlive = addStruct(v, numInts, numFloats, numStack, addInt, addFloat, addStack, keepAlive)
+	default:
+		panic("purego: unsupported kind: " + v.Kind().String())
+	}
+	return keepAlive
+}
 // maxRegAllocStructSize is the biggest a struct can be while still fitting in registers.
 // if it is bigger than this than enough space must be allocated on the heap and then passed into
 // the function as the first parameter on amd64 or in R8 on arm64.