Merge branch 'frozenset_immutable_tracking' of github.com:eendebakpt/cpython into frozenset_immutable_tracking

Author: eendebakpt

Lib/test/test_free_threading/test_uuid.py

@@ -0,0 +1,60 @@
+import os
+import unittest
+
+from test.support import import_helper, threading_helper
+from test.support.threading_helper import run_concurrently
+from uuid import SafeUUID
+
+c_uuid = import_helper.import_module("_uuid")
+
+NTHREADS = 10
+UUID_PER_THREAD = 1000
+
+
+@threading_helper.requires_working_threading()
+class UUIDTests(unittest.TestCase):
+    @unittest.skipUnless(os.name == "posix", "POSIX only")
+    def test_generate_time_safe(self):
+        uuids = []
+
+        def worker():
+            local_uuids = []
+            for _ in range(UUID_PER_THREAD):
+                uuid, is_safe = c_uuid.generate_time_safe()
+                self.assertIs(type(uuid), bytes)
+                self.assertEqual(len(uuid), 16)
+                # Collect the UUID only if it is safe. If not, we cannot ensure
+                # UUID uniqueness. According to uuid_generate_time_safe() man
+                # page, it is theoretically possible for two concurrently
+                # running processes to generate the same UUID(s) if the return
+                # value is not 0.
+                if is_safe == SafeUUID.safe:
+                    local_uuids.append(uuid)
+
+            # Merge all safe uuids
+            uuids.extend(local_uuids)
+
+        run_concurrently(worker_func=worker, nthreads=NTHREADS)
+        self.assertEqual(len(uuids), len(set(uuids)))
+
+    @unittest.skipUnless(os.name == "nt", "Windows only")
+    def test_UuidCreate(self):
+        uuids = []
+
+        def worker():
+            local_uuids = []
+            for _ in range(UUID_PER_THREAD):
+                uuid = c_uuid.UuidCreate()
+                self.assertIs(type(uuid), bytes)
+                self.assertEqual(len(uuid), 16)
+                local_uuids.append(uuid)
+
+            # Merge all uuids
+            uuids.extend(local_uuids)
+
+        run_concurrently(worker_func=worker, nthreads=NTHREADS)
+        self.assertEqual(len(uuids), len(set(uuids)))
+
+
+if __name__ == "__main__":
+    unittest.main()

Lib/test/test_sys.py

@@ -1876,7 +1876,10 @@ class S(set):
         check(S(), set(), '3P')
         class FS(frozenset):
             __slots__ = 'a', 'b', 'c'
-        check(FS(), frozenset(), '3P')
+
+        class mytuple(tuple):
+            pass
+        check(FS([mytuple()]), frozenset([mytuple()]), '3P')
         from collections import OrderedDict
         class OD(OrderedDict):
             __slots__ = 'a', 'b', 'c'

Misc/NEWS.d/next/Core_and_Builtins/2025-10-16-22-36-05.gh-issue-140232.u3srgv.rst

@@ -0,0 +1 @@
+Frozenset objects with immutable elements are no longer tracked by the garbage collector.

Objects/setobject.c

@@ -1177,10 +1177,10 @@ make_new_set_basetype(PyTypeObject *type, PyObject *iterable)
 void
 _PyFrozenSet_MaybeUntrack(PyObject *op)
 {
-    if ((op ==NULL) || !(PyFrozenSet_CheckExact(op))) {
+    if ((op == NULL) || !(PyFrozenSet_CheckExact(op))) {
         return;
     }
-    // the frozenset is tracked by the GC. if all elements are immutable we can untrack
+    // if all elements of a frozenset are not tracked, we untrack the object
     Py_ssize_t pos = 0;
     setentry *entry;
     while (set_next((PySetObject *)op, &pos, &entry)) {
@@ -2730,9 +2730,7 @@ PyObject *
 PyFrozenSet_New(PyObject *iterable)
 {
     PyObject *result = make_new_set(&PyFrozenSet_Type, iterable);
-    if (result != NULL) {
-        _PyFrozenSet_MaybeUntrack(result);
-    }
+    _PyFrozenSet_MaybeUntrack(result);
     return result;
 }