gh-100926: Move ctype's pointers cache to StgInfo

Doc/whatsnew/3.14.rst

@@ -510,6 +510,11 @@ ctypes
   loaded by the current process.
   (Contributed by Brian Ward in :gh:`119349`.)
 
+* Move :func:`ctypes.POINTER` types cache from the global ``_pointer_type_cache``
+  to the corresponding :mod:`ctypes` types. This will stop the cache from
+  growing without limits in some situations.
+  (Contributed by Sergey Miryanov in :gh:`100926`).
+
 datetime
 --------
 

Lib/ctypes/__init__.py

@@ -319,11 +319,9 @@ def SetPointerType(pointer, cls):
     warnings._deprecated("ctypes.SetPointerType", remove=(3, 15))
     if _pointer_type_cache.get(cls, None) is not None:
         raise RuntimeError("This type already exists in the cache")
-    if id(pointer) not in _pointer_type_cache:
-        raise RuntimeError("What's this???")
+
     pointer.set_type(cls)
     _pointer_type_cache[cls] = pointer
-    del _pointer_type_cache[id(pointer)]
 
 def ARRAY(typ, len):
     return typ * len

Lib/test/test_ctypes/test_byteswap.py

@@ -226,7 +226,6 @@ class TestStructure(parent):
                 self.assertEqual(len(data), sizeof(TestStructure))
                 ptr = POINTER(TestStructure)
                 s = cast(data, ptr)[0]
-                del ctypes._pointer_type_cache[TestStructure]
                 self.assertEqual(s.point.x, 1)
                 self.assertEqual(s.point.y, 2)
 
@@ -359,7 +358,6 @@ class TestUnion(parent):
                 self.assertEqual(len(data), sizeof(TestUnion))
                 ptr = POINTER(TestUnion)
                 s = cast(data, ptr)[0]
-                del ctypes._pointer_type_cache[TestUnion]
                 self.assertEqual(s.point.x, 1)
                 self.assertEqual(s.point.y, 2)
 

Lib/test/test_ctypes/test_keeprefs.py

@@ -1,6 +1,5 @@
 import unittest
-from ctypes import (Structure, POINTER, pointer,  _pointer_type_cache,
-                    c_char_p, c_int)
+from ctypes import (Structure, POINTER, pointer, c_char_p, c_int)
 
 
 class SimpleTestCase(unittest.TestCase):
@@ -115,10 +114,6 @@ class RECT(Structure):
         r.a[0].x = 42
         r.a[0].y = 99
 
-        # to avoid leaking when tests are run several times
-        # clean up the types left in the cache.
-        del _pointer_type_cache[POINT]
-
 
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_ctypes/test_pointers.py

@@ -3,7 +3,7 @@
 import sys
 import unittest
 from ctypes import (CDLL, CFUNCTYPE, Structure,
-                    POINTER, pointer, _Pointer, _pointer_type_cache,
+                    POINTER, pointer, _Pointer,
                     byref, sizeof,
                     c_void_p, c_char_p,
                     c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
@@ -141,8 +141,6 @@ class Table(Structure):
 
         pt.contents.c = 33
 
-        del _pointer_type_cache[Table]
-
     def test_basic(self):
         p = pointer(c_int(42))
         # Although a pointer can be indexed, it has no length
@@ -210,17 +208,11 @@ def test_pointer_type_name(self):
         LargeNamedType = type('T' * 2 ** 25, (Structure,), {})
         self.assertTrue(POINTER(LargeNamedType))
 
-        # to not leak references, we must clean _pointer_type_cache
-        del _pointer_type_cache[LargeNamedType]
-
     def test_pointer_type_str_name(self):
         large_string = 'T' * 2 ** 25
         P = POINTER(large_string)
         self.assertTrue(P)
 
-        # to not leak references, we must clean _pointer_type_cache
-        del _pointer_type_cache[id(P)]
-
     def test_abstract(self):
         self.assertRaises(TypeError, _Pointer.set_type, 42)
 

Lib/test/test_ctypes/test_values.py

@@ -7,7 +7,6 @@
 import sys
 import unittest
 from ctypes import (Structure, CDLL, POINTER, pythonapi,
-                    _pointer_type_cache,
                     c_ubyte, c_char_p, c_int)
 from test.support import import_helper
 
@@ -96,8 +95,6 @@ class struct_frozen(Structure):
                          "_PyImport_FrozenBootstrap example "
                          "in Doc/library/ctypes.rst may be out of date")
 
-        del _pointer_type_cache[struct_frozen]
-
     def test_undefined(self):
         self.assertRaises(ValueError, c_int.in_dll, pythonapi,
                           "Undefined_Symbol")

Lib/test/test_ctypes/test_win32.py

@@ -5,7 +5,6 @@
 import sys
 import unittest
 from ctypes import (CDLL, Structure, POINTER, pointer, sizeof, byref,
-                    _pointer_type_cache,
                     c_void_p, c_char, c_int, c_long)
 from test import support
 from test.support import import_helper
@@ -145,8 +144,8 @@ class RECT(Structure):
             self.assertEqual(ret.top, top.value)
             self.assertEqual(ret.bottom, bottom.value)
 
-        # to not leak references, we must clean _pointer_type_cache
-        del _pointer_type_cache[RECT]
+        self.assertEqual(id(PointInRect.argtypes[0]), id(ReturnRect.argtypes[2]))
+        self.assertEqual(id(PointInRect.argtypes[0]), id(ReturnRect.argtypes[5]))
 
 
 if __name__ == '__main__':

Misc/NEWS.d/next/Library/2025-03-17-23-07-57.gh-issue-100926.B8gcbz.rst

@@ -0,0 +1,2 @@
+Move :func:`ctypes.POINTER` types cache from the global ``_pointer_type_cache``
+to the corresponding :mod:`ctypes` types to avoid unlimited growth of the cache.

Modules/_ctypes/_ctypes.c

@@ -474,6 +474,7 @@ CType_Type_traverse(PyObject *self, visitproc visit, void *arg)
         Py_VISIT(info->restype);
         Py_VISIT(info->checker);
         Py_VISIT(info->module);
+        Py_VISIT(info->pointer_type);
     }
     Py_VISIT(Py_TYPE(self));
     return PyType_Type.tp_traverse(self, visit, arg);
@@ -488,7 +489,8 @@ ctype_clear_stginfo(StgInfo *info)
     Py_CLEAR(info->converters);
     Py_CLEAR(info->restype);
     Py_CLEAR(info->checker);
-    Py_CLEAR(info->module);
+    Py_CLEAR(info->pointer_type);
+    Py_CLEAR(info->module);  // decref the module last
 }
 
 static int

Modules/_ctypes/callproc.c

@@ -1990,14 +1990,24 @@ create_pointer_type(PyObject *module, PyObject *cls)
 {
     PyObject *result;
     PyTypeObject *typ;
-    PyObject *key;
 
     assert(module);
     ctypes_state *st = get_module_state(module);
+    StgInfo *info = NULL;
+    if (PyType_Check(cls)) {
+        if (PyStgInfo_FromType(st, cls, &info) < 0) {
+            return NULL;
+        }
+        if (info && info->pointer_type) {
+            return Py_NewRef(info->pointer_type);
+        }
+    }
+
     if (PyDict_GetItemRef(st->_ctypes_ptrtype_cache, cls, &result) != 0) {
         // found or error
         return result;
     }
+
     // not found
     if (PyUnicode_CheckExact(cls)) {
         PyObject *name = PyUnicode_FromFormat("LP_%U", cls);
@@ -2007,11 +2017,6 @@ create_pointer_type(PyObject *module, PyObject *cls)
                                        st->PyCPointer_Type);
         if (result == NULL)
             return result;
-        key = PyLong_FromVoidPtr(result);
-        if (key == NULL) {
-            Py_DECREF(result);
-            return NULL;
-        }
     } else if (PyType_Check(cls)) {
         typ = (PyTypeObject *)cls;
         PyObject *name = PyUnicode_FromFormat("LP_%s", typ->tp_name);
@@ -2022,17 +2027,15 @@ create_pointer_type(PyObject *module, PyObject *cls)
                                        "_type_", cls);
         if (result == NULL)
             return result;
-        key = Py_NewRef(cls);
     } else {
         PyErr_SetString(PyExc_TypeError, "must be a ctypes type");
         return NULL;
     }
-    if (PyDict_SetItem(st->_ctypes_ptrtype_cache, key, result) < 0) {
-        Py_DECREF(result);
-        Py_DECREF(key);
-        return NULL;
+
+    if (info) {
+        info->pointer_type = Py_NewRef(result);
     }
-    Py_DECREF(key);
+
     return result;
 }
 
@@ -2056,15 +2059,10 @@ create_pointer_inst(PyObject *module, PyObject *arg)
     PyObject *result;
     PyObject *typ;
 
-    ctypes_state *st = get_module_state(module);
-    if (PyDict_GetItemRef(st->_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg), &typ) < 0) {
+    typ = create_pointer_type(module, (PyObject *)Py_TYPE(arg));
+    if (typ == NULL)
         return NULL;
-    }
-    if (typ == NULL) {
-        typ = create_pointer_type(module, (PyObject *)Py_TYPE(arg));
-        if (typ == NULL)
-            return NULL;
-    }
+
     result = PyObject_CallOneArg(typ, arg);
     Py_DECREF(typ);
     return result;

Modules/_ctypes/ctypes.h

@@ -373,6 +373,7 @@ typedef struct {
     Py_ssize_t *shape;
 /*      Py_ssize_t *strides;    */ /* unused in ctypes */
 /*      Py_ssize_t *suboffsets; */ /* unused in ctypes */
+    PyObject *pointer_type;
 } StgInfo;
 
 extern int PyCStgInfo_clone(StgInfo *dst_info, StgInfo *src_info);
@@ -566,6 +567,7 @@ PyStgInfo_Init(ctypes_state *state, PyTypeObject *type)
         return NULL;
     }
     info->module = Py_NewRef(module);
+    info->pointer_type = NULL;
 
     info->initialized = 1;
     return info;

Modules/_ctypes/stgdict.c

@@ -41,6 +41,7 @@ PyCStgInfo_clone(StgInfo *dst_info, StgInfo *src_info)
     Py_XINCREF(dst_info->restype);
     Py_XINCREF(dst_info->checker);
     Py_XINCREF(dst_info->module);
+    Py_XINCREF(dst_info->pointer_type);
 
     if (src_info->format) {
         dst_info->format = PyMem_Malloc(strlen(src_info->format) + 1);