don't dealloc PyMethodDef object until cleaning

Author: cpunion

extension.go

@@ -50,6 +50,7 @@ type slotMeta struct {
 	hasRecv    bool         // whether it has a receiver
 	index      int          // used for member type
 	typ        reflect.Type // member/method type
+	def        *C.PyMethodDef
 }
 
 type typeMeta struct {
@@ -627,25 +628,27 @@ func (m Module) AddMethod(name string, fn any, doc string) Func {
 	}
 
 	methodId := uint(len(meta.methods))
-	meta.methods[methodId] = &slotMeta{
+
+	methodPtr := C.wrapperMethods[methodId]
+	cName := C.CString(name)
+	cDoc := C.CString(doc)
+
+	def := (*C.PyMethodDef)(C.malloc(C.size_t(unsafe.Sizeof(C.PyMethodDef{}))))
+	def.ml_name = cName
+	def.ml_meth = C.PyCFunction(methodPtr)
+	def.ml_flags = C.METH_VARARGS
+	def.ml_doc = cDoc
+
+	methodMeta := &slotMeta{
 		name:       name,
 		methodName: name,
 		fn:         fn,
 		typ:        t,
 		doc:        doc,
 		hasRecv:    false,
+		def:        def,
 	}
-
-	methodPtr := C.wrapperMethods[methodId]
-	cName := C.CString(name)
-	cDoc := C.CString(doc)
-
-	def := &C.PyMethodDef{
-		ml_name:  cName,
-		ml_meth:  C.PyCFunction(methodPtr),
-		ml_flags: C.METH_VARARGS,
-		ml_doc:   cDoc,
-	}
+	meta.methods[methodId] = methodMeta
 
 	pyFunc := C.PyCFunction_NewEx(def, m.obj, m.obj)
 	if pyFunc == nil {

global_data.go

@@ -9,6 +9,7 @@ import (
 	"reflect"
 	"sync"
 	"sync/atomic"
+	"unsafe"
 )
 
 // ----------------------------------------------------------------------------
@@ -51,11 +52,15 @@ func (l *decRefList) add(obj *C.PyObject) {
 	l.mu.Unlock()
 }
 
-func (l *decRefList) decRefAll() {
-	var list []*C.PyObject
+func (l *decRefList) len() int {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return len(l.objects)
+}
 
+func (l *decRefList) decRefAll() {
 	l.mu.Lock()
-	list = l.objects
+	list := l.objects
 	l.objects = make([]*C.PyObject, 0, maxPyObjects*2)
 	l.mu.Unlock()
 
@@ -67,12 +72,11 @@ func (l *decRefList) decRefAll() {
 // ----------------------------------------------------------------------------
 
 type globalData struct {
-	typeMetas     map[*C.PyObject]*typeMeta
-	pyTypes       map[reflect.Type]*C.PyObject
-	holders       holderList
-	decRefList    decRefList
-	disableDecRef bool
-	finished      int32
+	typeMetas  map[*C.PyObject]*typeMeta
+	pyTypes    map[reflect.Type]*C.PyObject
+	holders    holderList
+	decRefList decRefList
+	finished   int32
 }
 
 var (
@@ -84,17 +88,16 @@ func getGlobalData() *globalData {
 }
 
 func (gd *globalData) addDecRef(obj *C.PyObject) {
-	if gd.disableDecRef {
-		return
-	}
 	if atomic.LoadInt32(&gd.finished) != 0 {
 		return
 	}
 	gd.decRefList.add(obj)
 }
 
 func (gd *globalData) decRefObjectsIfNeeded() {
-	gd.decRefList.decRefAll()
+	if gd.decRefList.len() >= maxPyObjects {
+		gd.decRefList.decRefAll()
+	}
 }
 
 // ----------------------------------------------------------------------------
@@ -111,5 +114,15 @@ func markFinished() {
 }
 
 func cleanupGlobal() {
+	for _, meta := range global.typeMetas {
+		for _, method := range meta.methods {
+			def := method.def
+			if def != nil {
+				C.free(unsafe.Pointer(def.ml_name))
+				C.free(unsafe.Pointer(def.ml_doc))
+				C.free(unsafe.Pointer(def))
+			}
+		}
+	}
 	global = nil
 }

python_test.go

@@ -14,7 +14,6 @@ func setupTest(t *testing.T) {
 	testMutex.Lock()
 	Initialize()
 	// TODO: Remove this once we solve random segfaults
-	getGlobalData().disableDecRef = true
 	t.Cleanup(func() {
 		runtime.GC()
 		Finalize()