GH-132657: Add lock-free set contains implementation

Include/internal/pycore_pyatomic_ft_wrappers.h

@@ -57,6 +57,8 @@ extern "C" {
     _Py_atomic_store_uintptr_release(&value, new_value)
 #define FT_ATOMIC_STORE_SSIZE_RELAXED(value, new_value) \
     _Py_atomic_store_ssize_relaxed(&value, new_value)
+#define FT_ATOMIC_STORE_SSIZE_RELEASE(value, new_value) \
+    _Py_atomic_store_ssize_release(&value, new_value)
 #define FT_ATOMIC_STORE_UINT8_RELAXED(value, new_value) \
     _Py_atomic_store_uint8_relaxed(&value, new_value)
 #define FT_ATOMIC_STORE_UINT16_RELAXED(value, new_value) \
@@ -140,6 +142,7 @@ extern "C" {
 #define FT_ATOMIC_STORE_PTR_RELEASE(value, new_value) value = new_value
 #define FT_ATOMIC_STORE_UINTPTR_RELEASE(value, new_value) value = new_value
 #define FT_ATOMIC_STORE_SSIZE_RELAXED(value, new_value) value = new_value
+#define FT_ATOMIC_STORE_SSIZE_RELEASE(value, new_value) value = new_value
 #define FT_ATOMIC_STORE_UINT8_RELAXED(value, new_value) value = new_value
 #define FT_ATOMIC_STORE_UINT16_RELAXED(value, new_value) value = new_value
 #define FT_ATOMIC_STORE_UINT32_RELAXED(value, new_value) value = new_value

Lib/test/test_free_threading/test_set.py

@@ -1,18 +1,14 @@
 import unittest
-
 from threading import Thread, Barrier
-from unittest import TestCase
-
 from test.support import threading_helper
 
 
-@threading_helper.requires_working_threading()
-class TestSet(TestCase):
+class TestSetRepr(unittest.TestCase):
     def test_repr_clear(self):
         """Test repr() of a set while another thread is calling clear()"""
         NUM_ITERS = 10
         NUM_REPR_THREADS = 10
-        barrier = Barrier(NUM_REPR_THREADS + 1)
+        barrier = Barrier(NUM_REPR_THREADS + 1, timeout=2)
         s = {1, 2, 3, 4, 5, 6, 7, 8}
 
         def clear_set():
@@ -37,5 +33,133 @@ def repr_set():
                 self.assertIn(set_repr, ("set()", "{1, 2, 3, 4, 5, 6, 7, 8}"))
 
 
+class RaceTestBase:
+    def test_contains_mutate(self):
+        """Test set contains operation combined with mutation."""
+        barrier = Barrier(2, timeout=2)
+        s = set()
+        done = False
+
+        NUM_LOOPS = 1000
+
+        def read_set():
+            barrier.wait()
+            while not done:
+                for i in range(self.SET_SIZE):
+                    item = i >> 1
+                    result = item in s
+
+        def mutate_set():
+            nonlocal done
+            barrier.wait()
+            for i in range(NUM_LOOPS):
+                s.clear()
+                for j in range(self.SET_SIZE):
+                    s.add(j)
+                for j in range(self.SET_SIZE):
+                    s.discard(j)
+                # executes the set_swap_bodies() function
+                s.__iand__(set(k for k in range(10, 20)))
+            done = True
+
+        threads = [Thread(target=read_set), Thread(target=mutate_set)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+    def test_contains_frozenset(self):
+        barrier = Barrier(3, timeout=2)
+        done = False
+
+        NUM_LOOPS = 1_000
+
+        # This mutates the key used for contains test, not the container
+        # itself.  This works because frozenset allows the key to be a set().
+        s = set()
+
+        def mutate_set():
+            barrier.wait()
+            while not done:
+                s.add(0)
+                s.add(1)
+                s.clear()
+
+        def read_set():
+            nonlocal done
+            barrier.wait()
+            container = frozenset([frozenset([0])])
+            self.assertTrue(set([0]) in container)
+            for _ in range(NUM_LOOPS):
+                # Will return True when {0} is the key and False otherwise
+                result = s in container
+            done = True
+
+        threads = [
+            Thread(target=read_set),
+            Thread(target=read_set),
+            Thread(target=mutate_set),
+        ]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+    def test_contains_hash_mutate(self):
+        """Test set contains operation with mutating hash method."""
+        barrier = Barrier(2, timeout=2)
+
+        NUM_LOOPS = 1_000
+        SET_SIZE = self.SET_SIZE
+
+        s = set(range(SET_SIZE))
+
+        class Key:
+            def __init__(self):
+                self.count = 0
+                self.value = 0
+
+            def __hash__(self):
+                self.count += 1
+                # This intends to trigger the SET_LOOKKEY_CHANGED case
+                # of set_lookkey_threadsafe() since calling clear()
+                # will cause the 'table' pointer to change.
+                if self.count % 2 == 0:
+                    s.clear()
+                else:
+                    s.update(range(SET_SIZE))
+                return hash(self.value)
+
+            def __eq__(self, other):
+                return self.value == other
+
+        key = Key()
+        self.assertTrue(key in s)
+        self.assertFalse(key in s)
+        self.assertTrue(key in s)
+        self.assertFalse(key in s)
+
+        def read_set():
+            barrier.wait()
+            for i in range(NUM_LOOPS):
+                result = key in s
+
+        threads = [Thread(target=read_set), Thread(target=read_set)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+
+@threading_helper.requires_working_threading()
+class SmallSetTest(RaceTestBase, unittest.TestCase):
+    SET_SIZE = 6  # smaller than PySet_MINSIZE
+
+
+@threading_helper.requires_working_threading()
+class LargeSetTest(RaceTestBase, unittest.TestCase):
+    SET_SIZE = 20  # larger than PySet_MINSIZE
+
+
 if __name__ == "__main__":
     unittest.main()

Misc/NEWS.d/next/Core_and_Builtins/2025-07-11-19-57-27.gh-issue-132657.vwDuO2.rst

@@ -0,0 +1,2 @@
+For the free-threaded build, avoid locking the :class:`set` object for the
+``__contains__`` method.