multi-threaded allocation test

tests/CMakeLists.txt

@@ -46,6 +46,7 @@ nanobind_add_module(test_exception_ext test_exception.cpp ${NB_EXTRA_ARGS})
 nanobind_add_module(test_make_iterator_ext test_make_iterator.cpp ${NB_EXTRA_ARGS})
 nanobind_add_module(test_typing_ext test_typing.cpp ${NB_EXTRA_ARGS})
 nanobind_add_module(test_issue_ext test_issue.cpp ${NB_EXTRA_ARGS})
+nanobind_add_module(test_thread_ext test_thread.cpp ${NB_EXTRA_ARGS})
 
 foreach (NAME functions classes ndarray stl enum typing make_iterator)
   if (NAME STREQUAL typing)
@@ -120,6 +121,7 @@ set(TEST_FILES
   test_ndarray.py
   test_stubs.py
   test_typing.py
+  test_thread.py
 
   # Stub reference files
   test_classes_ext.pyi.ref

tests/test_thread.cpp

@@ -0,0 +1,16 @@
+#include <nanobind/nanobind.h>
+#include <atomic>
+
+namespace nb = nanobind;
+
+struct Counter {
+    std::atomic<size_t> counter { 0 };
+    void inc() { counter++; }
+};
+
+NB_MODULE(test_thread_ext, m) {
+    nb::class_<Counter>(m, "Counter")
+        .def(nb::init<>())
+        .def_prop_ro("counter", [](Counter &c) { return (size_t) c.counter; })
+        .def("inc", &Counter::inc);
+}

tests/test_thread.py

@@ -0,0 +1,40 @@
+# Temporarily turn off immortalization
+try:
+    from test.support import suppress_immortalization
+except ImportError:
+    from contextlib import nullcontext as suppress_immortalization
+
+import test_thread_ext as t
+
+import threading
+import gc
+
+def parallelize(func, n_threads):
+    with suppress_immortalization(True): # Avoid reference leak errors
+        barrier = threading.Barrier(n_threads)
+
+        def wrapper():
+            barrier.wait()
+            return func()
+
+        workers = []
+        for _ in range(n_threads):
+            t = threading.Thread(target=wrapper)
+            t.start()
+            workers.append(t)
+
+        for worker in workers:
+            worker.join()
+
+def test01_object_creation():
+    from test_thread_ext import Counter
+
+    def f():
+        n = 1000000
+        r = [None]*n
+        for i in range(n):
+            r[i] = Counter()
+        del r
+
+    parallelize(f, n_threads=8)
+    gc.collect()