Add a test for shared-GIL (legacy) subinterpreters

Author: b-pass

tests/CMakeLists.txt

@@ -566,9 +566,12 @@ add_custom_target(
 if(NOT PYBIND11_CUDA_TESTS)
   # This module doesn't get mixed with other test modules because those aren't subinterpreter safe.
   pybind11_add_module(mod_test_interpreters THIN_LTO mod_test_interpreters.cpp)
+  pybind11_add_module(mod_test_interpreters2 THIN_LTO mod_test_interpreters2.cpp)
   set_target_properties(mod_test_interpreters PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                                                          "$<1:${CMAKE_CURRENT_BINARY_DIR}>")
-  add_dependencies(pytest mod_test_interpreters)
+  set_target_properties(mod_test_interpreters2 PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                                          "$<1:${CMAKE_CURRENT_BINARY_DIR}>")
+  add_dependencies(pytest mod_test_interpreters mod_test_interpreters2)
 endif()
 
 if(PYBIND11_TEST_OVERRIDE)

tests/mod_test_interpreters2.cpp

@@ -0,0 +1,14 @@
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+/* Simple test module/test class to check that the referenced internals data of external pybind11
+ * modules are different across subinterpreters
+ */
+
+PYBIND11_MODULE(mod_test_interpreters2,
+                m,
+                py::multiple_interpreters(py::multiple_interpreters::shared_gil)) {
+    m.def("internals_at",
+          []() { return reinterpret_cast<uintptr_t>(&py::detail::get_internals()); });
+}

tests/test_interpreters.py

@@ -10,8 +10,8 @@
 @pytest.mark.skipif(
     sys.platform.startswith("emscripten"), reason="Requires loadable modules"
 )
-def test_interpreters():
-    """Makes sure the internals object differs across subinterpreters"""
+def test_independent_subinterpreters():
+    """Makes sure the internals object differs across independent subinterpreters"""
 
     sys.path.append(".")
 
@@ -36,6 +36,8 @@ def test_interpreters():
     interp1 = interpreters.create()
     interp2 = interpreters.create()
     try:
+        res0 = interpreters.run_string(interp1, "import mod_test_interpreters2")
+
         pipei, pipeo = os.pipe()
         interpreters.run_string(interp1, code, shared={"pipeo": pipeo})
         with open(pipei, "rb") as f:
@@ -56,6 +58,7 @@ def test_interpreters():
         interpreters.destroy(interp1)
         interpreters.destroy(interp2)
 
+    assert "does not support loading in subinterpreters" in res0.msg, "cannot use shared_gil in a default subinterpreter"
     assert res1 != m.internals_at(), "internals should differ from main interpreter"
     assert res2 != m.internals_at(), "internals should differ from main interpreter"
     assert res1 != res2, "internals should differ between interpreters"
@@ -66,3 +69,53 @@ def test_interpreters():
     assert m.internals_at() == m3.internals_at(), (
         "internals should be the same within the main interpreter"
     )
+
+@pytest.mark.skipif(
+    sys.platform.startswith("emscripten"), reason="Requires loadable modules"
+)
+def test_dependent_subinterpreters():
+    """Makes sure the internals object differs across subinterpreters"""
+
+    sys.path.append(".")
+
+    if sys.version_info >= (3, 14):
+        import interpreters
+    elif sys.version_info >= (3, 13):
+        import _interpreters as interpreters
+    elif sys.version_info >= (3, 12):
+        import _xxsubinterpreters as interpreters
+    else:
+        pytest.skip("Test requires a the interpreters stdlib module")
+
+    import mod_test_interpreters2 as m
+
+    code = """
+import mod_test_interpreters2 as m
+import pickle
+with open(pipeo, 'wb') as f:
+    pickle.dump(m.internals_at(), f)
+"""
+
+    interp1 = interpreters.create("legacy")
+    try:
+        pipei, pipeo = os.pipe()
+        interpreters.run_string(interp1, code, shared={"pipeo": pipeo})
+        with open(pipei, "rb") as f:
+            res1 = pickle.load(f)
+
+        # do this while the two interpreters are active
+        import mod_test_interpreters2 as m2
+
+        assert m.internals_at() == m2.internals_at(), (
+            "internals should be the same within the main interpreter"
+        )
+    finally:
+        interpreters.destroy(interp1)
+
+    assert res1 != m.internals_at(), "internals should differ from main interpreter"
+
+    # do this after the two interpreters are destroyed and only one remains
+    import mod_test_interpreters2 as m3
+    assert m.internals_at() == m3.internals_at(), (
+        "internals should be the same within the main interpreter"
+    )