use global state

Author: cpunion

convert.go

@@ -63,7 +63,7 @@ func From(v any) Object {
 		switch vv.Kind() {
 		case reflect.Ptr:
 			if vv.Elem().Type().Kind() == reflect.Struct {
-				maps := getCurrentThreadData()
+				maps := getGlobalData()
 				if pyType, ok := maps.pyTypes[vv.Elem().Type()]; ok {
 					wrapper := allocWrapper((*C.PyTypeObject)(unsafe.Pointer(pyType)), vv.Interface())
 					return newObject((*C.PyObject)(unsafe.Pointer(wrapper)))
@@ -173,7 +173,7 @@ func ToValue(obj Object, v reflect.Value) bool {
 				}
 			}
 		} else {
-			maps := getCurrentThreadData()
+			maps := getGlobalData()
 			tyMeta := maps.typeMetas[obj.Type().Obj()]
 			if tyMeta == nil {
 				return false
@@ -192,7 +192,7 @@ func fromSlice(v reflect.Value) List {
 	l := v.Len()
 	list := newList(C.PyList_New(C.Py_ssize_t(l)))
 	ty := v.Type().Elem()
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	pyType, ok := maps.pyTypes[ty]
 	if !ok {
 		for i := 0; i < l; i++ {
@@ -221,7 +221,7 @@ func fromMap(v reflect.Value) Dict {
 
 func fromStruct(v reflect.Value) Object {
 	ty := v.Type()
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	if typeObj, ok := maps.pyTypes[ty]; ok {
 		ptr := reflect.New(ty)
 		ptr.Elem().Set(v)

extension.go

@@ -66,21 +66,21 @@ func allocWrapper(typ *C.PyTypeObject, obj any) *wrapperType {
 	wrapper := (*wrapperType)(unsafe.Pointer(self))
 	holder := new(objectHolder)
 	holder.obj = obj
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	maps.holders.PushFront(holder)
 	wrapper.goObj = holder.obj
 	wrapper.holder = holder
 	return wrapper
 }
 
 func freeWrapper(wrapper *wrapperType) {
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	maps.holders.Remove(wrapper.holder)
 }
 
 //export wrapperAlloc
 func wrapperAlloc(typ *C.PyTypeObject, size C.Py_ssize_t) *C.PyObject {
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	meta := maps.typeMetas[(*C.PyObject)(unsafe.Pointer(typ))]
 	wrapper := allocWrapper(typ, reflect.New(meta.typ).Interface())
 	if wrapper == nil {
@@ -99,7 +99,7 @@ func wrapperDealloc(self *C.PyObject) {
 //export wrapperInit
 func wrapperInit(self, args *C.PyObject) C.int {
 	typ := (*C.PyObject)(self).ob_type
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	typeMeta := maps.typeMetas[(*C.PyObject)(unsafe.Pointer(typ))]
 	if typeMeta.init == nil {
 		return 0
@@ -112,7 +112,7 @@ func wrapperInit(self, args *C.PyObject) C.int {
 
 //export getterMethod
 func getterMethod(self *C.PyObject, _closure unsafe.Pointer, methodId C.int) *C.PyObject {
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	typeMeta := maps.typeMetas[(*C.PyObject)(unsafe.Pointer(self.ob_type))]
 	if typeMeta == nil {
 		SetError(fmt.Errorf("type %v not registered", FromPy(self)))
@@ -157,7 +157,7 @@ func getterMethod(self *C.PyObject, _closure unsafe.Pointer, methodId C.int) *C.
 
 //export setterMethod
 func setterMethod(self, value *C.PyObject, _closure unsafe.Pointer, methodId C.int) C.int {
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	typeMeta := maps.typeMetas[(*C.PyObject)(unsafe.Pointer(self.ob_type))]
 	if typeMeta == nil {
 		SetError(fmt.Errorf("type %v not registered", FromPy(self)))
@@ -238,7 +238,7 @@ func wrapperMethod(self, args *C.PyObject, methodId C.int) *C.PyObject {
 		key = (*C.PyObject)(unsafe.Pointer(self.ob_type))
 	}
 
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	typeMeta, ok := maps.typeMetas[key]
 	if !ok {
 		SetError(fmt.Errorf("type %v not registered", FromPy(key)))
@@ -457,7 +457,7 @@ func (m Module) AddType(obj, init any, name, doc string) Object {
 	}
 
 	// Check if type already registered
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	if pyType, ok := maps.pyTypes[ty]; ok {
 		return newObject(pyType)
 	}
@@ -569,7 +569,7 @@ func (m Module) AddType(obj, init any, name, doc string) Object {
 		}
 		// Recursively register struct types
 		if fieldType.Kind() == reflect.Struct {
-			maps := getCurrentThreadData()
+			maps := getGlobalData()
 			if _, ok := maps.pyTypes[fieldType]; !ok {
 				// Generate a unique type name based on package path and type name
 				nestedName := fieldType.Name()
@@ -600,7 +600,7 @@ func (m Module) AddMethod(name string, fn any, doc string) Func {
 	name = goNameToPythonName(name)
 	doc = name + doc
 
-	maps := getCurrentThreadData()
+	maps := getGlobalData()
 	meta, ok := maps.typeMetas[m.obj]
 	if !ok {
 		meta = &typeMeta{

function.go

@@ -36,12 +36,12 @@ func (f Func) callOneArg(arg Objecter) Object {
 }
 
 func (f Func) CallObject(args Tuple) Object {
-	defer getCurrentThreadData().decRefObjectsIfNeeded()
+	defer getGlobalData().decRefObjectsIfNeeded()
 	return newObject(C.PyObject_CallObject(f.obj, args.obj))
 }
 
 func (f Func) CallObjectKw(args Tuple, kw KwArgs) Object {
-	defer getCurrentThreadData().decRefObjectsIfNeeded()
+	defer getGlobalData().decRefObjectsIfNeeded()
 	// Convert keyword arguments to Python dict
 	kwDict := MakeDict(nil)
 	for k, v := range kw {
@@ -53,7 +53,7 @@ func (f Func) CallObjectKw(args Tuple, kw KwArgs) Object {
 func (f Func) Call(args ...any) Object {
 	argsTuple, kwArgs := splitArgs(args...)
 	if kwArgs == nil {
-		defer getCurrentThreadData().decRefObjectsIfNeeded()
+		defer getGlobalData().decRefObjectsIfNeeded()
 		switch len(args) {
 		case 0:
 			return f.callNoArgs()

thread_local.go global_data.gothread_local.go renamed to global_data.go

@@ -6,12 +6,12 @@ package gp
 import "C"
 
 import (
-	"fmt"
 	"reflect"
-	"runtime"
 	"sync"
 )
 
+// ----------------------------------------------------------------------------
+
 type holderList struct {
 	head *objectHolder
 }
@@ -35,6 +35,10 @@ func (l *holderList) Remove(holder *objectHolder) {
 	}
 }
 
+// ----------------------------------------------------------------------------
+
+const maxPyObjects = 128
+
 type decRefList struct {
 	objects []*C.PyObject
 	mu      sync.Mutex
@@ -59,69 +63,52 @@ func (l *decRefList) decRefAll() {
 	}
 }
 
-type threadData struct {
+// ----------------------------------------------------------------------------
+
+type globalData struct {
 	typeMetas  map[*C.PyObject]*typeMeta
 	pyTypes    map[reflect.Type]*C.PyObject
 	holders    holderList
 	decRefList decRefList
+	finished   int32
 }
 
-const maxPyObjects = 128
+var (
+	global *globalData
+	once   sync.Once
+)
 
-func (td *threadData) addPyObject(obj *C.PyObject) {
-	td.decRefList.add(obj)
+func getGlobalData() *globalData {
+	return global
 }
 
-func (td *threadData) decRefObjectsIfNeeded() {
-	if len(td.decRefList.objects) > maxPyObjects {
-		td.decRefList.decRefAll()
+func (gd *globalData) addDecRef(obj *C.PyObject) {
+	if gd.finished != 0 {
+		return
 	}
+	gd.decRefList.add(obj)
 }
 
-var (
-	globalThreadData sync.Map // map[int64]*threadData
-)
-
-func getCurrentThreadData() *threadData {
-	id := getThreadID()
-	return getThreadData(id)
-}
-
-func getThreadData(gid int64) *threadData {
-	id := getThreadID()
-	maps, ok := globalThreadData.Load(id)
-	if !ok {
-		// if not exists, create new thread data
-		maps = &threadData{
-			typeMetas: make(map[*C.PyObject]*typeMeta),
-			pyTypes:   make(map[reflect.Type]*C.PyObject),
-		}
-		globalThreadData.Store(id, maps)
+func (gd *globalData) decRefObjectsIfNeeded() {
+	if gd.finished != 0 {
+		return
 	}
-	return maps.(*threadData)
+	gd.decRefList.decRefAll()
 }
 
-func initThreadLocal() {
-	id := getThreadID()
-	maps := &threadData{
+// ----------------------------------------------------------------------------
+
+func initGlobal() {
+	global = &globalData{
 		typeMetas: make(map[*C.PyObject]*typeMeta),
 		pyTypes:   make(map[reflect.Type]*C.PyObject),
 	}
-	globalThreadData.Store(id, maps)
 }
 
-func cleanupThreadLocal() {
-	id := getThreadID()
-	globalThreadData.Delete(id)
+func markFinished() {
+	global.finished = 1
 }
 
-func getThreadID() int64 {
-	var buf [64]byte
-	n := runtime.Stack(buf[:], false)
-	id := int64(0)
-	_, err := fmt.Sscanf(string(buf[:n]), "goroutine %d ", &id)
-	if err != nil {
-		panic(err)
-	}
-	return id
+func cleanupGlobal() {
+	global = nil
 }

module_test.go

@@ -6,9 +6,6 @@ import (
 
 func TestModuleImport(t *testing.T) {
 	setupTest(t)
-	Initialize()
-	defer Finalize()
-
 	// Test importing a built-in module
 	mathMod := ImportModule("math")
 	if mathMod.Nil() {
@@ -29,9 +26,6 @@ func TestModuleImport(t *testing.T) {
 
 func TestGetModule(t *testing.T) {
 	setupTest(t)
-	Initialize()
-	defer Finalize()
-
 	// First import the module
 	sysModule := ImportModule("sys")
 	if sysModule.Nil() {
@@ -52,8 +46,6 @@ func TestGetModule(t *testing.T) {
 
 func TestCreateModule(t *testing.T) {
 	setupTest(t)
-	Initialize()
-	defer Finalize()
 
 	// Create a new module
 	modName := "test_module"
@@ -84,8 +76,6 @@ func TestCreateModule(t *testing.T) {
 
 func TestGetModuleDict(t *testing.T) {
 	setupTest(t)
-	Initialize()
-	defer Finalize()
 
 	// Get the module dictionary
 	moduleDict := GetModuleDict()

object.go

@@ -15,7 +15,6 @@ import (
 // the Python Object's DecRef method during garbage collection.
 type pyObject struct {
 	obj *C.PyObject
-	gid int64
 }
 
 func (obj *pyObject) Obj() *PyObject {
@@ -55,14 +54,12 @@ func newObject(obj *PyObject) Object {
 		C.PyErr_Print()
 		panic("nil Python object")
 	}
-	o := &pyObject{obj: obj, gid: getThreadID()}
-	p := Object{o}
-
+	o := &pyObject{obj: obj}
 	runtime.SetFinalizer(o, func(o *pyObject) {
-		maps := getThreadData(o.gid)
-		maps.addPyObject(o.obj)
+		getGlobalData().addDecRef(o.obj)
+		runtime.SetFinalizer(o, nil)
 	})
-	return p
+	return Object{o}
 }
 
 func (obj Object) Dir() List {

python.go

@@ -17,12 +17,13 @@ type PyCFunction = C.PyCFunction
 func Initialize() {
 	runtime.LockOSThread()
 	C.Py_Initialize()
-	initThreadLocal()
+	initGlobal()
 }
 
 func Finalize() {
-	cleanupThreadLocal()
+	markFinished()
 	r := C.Py_FinalizeEx()
+	cleanupGlobal()
 	check(r == 0, "failed to finalize Python")
 }