Update the global cache while still under the main interpreter.

Author: ericsnowcurrently

Lib/test/test_import/__init__.py

@@ -3014,20 +3014,20 @@ def test_basic_multiple_interpreters_deleted_no_reset(self):
         #  * alive in 0 interpreters
         #  * module def in _PyRuntime.imports.extensions
         #  * mod init func ran for the first time (since reset)
-        #  * m_copy is NULL (claered when the interpreter was destroyed)
+        #  * m_copy is still set (owned by main interpreter)
         #  * module's global state was initialized, not reset
 
         # Use a subinterpreter that sticks around.
         loaded_interp1 = self.import_in_subinterp(interpid1)
         self.check_common(loaded_interp1)
-        self.check_semi_fresh(loaded_interp1, loaded_main, base)
+        self.check_copied(loaded_interp1, base)
 
         # At this point:
         #  * alive in 1 interpreter (interp1)
         #  * module def still in _PyRuntime.imports.extensions
-        #  * mod init func ran for the second time (since reset)
-        #  * m_copy was copied from interp1 (was NULL)
-        #  * module's global state was updated, not reset
+        #  * mod init func did not run again
+        #  * m_copy was not changed
+        #  * module's global state was not touched
 
         # Use a subinterpreter while the previous one is still alive.
         loaded_interp2 = self.import_in_subinterp(interpid2)
@@ -3038,8 +3038,8 @@ def test_basic_multiple_interpreters_deleted_no_reset(self):
         #  * alive in 2 interpreters (interp1, interp2)
         #  * module def still in _PyRuntime.imports.extensions
         #  * mod init func did not run again
-        #  * m_copy was copied from interp2 (was from interp1)
-        #  * module's global state was updated, not reset
+        #  * m_copy was not changed
+        #  * module's global state was not touched
 
     @requires_subinterpreters
     def test_basic_multiple_interpreters_reset_each(self):

Python/import.c

@@ -1967,6 +1967,46 @@ import_run_extension(PyThreadState *tstate, PyModInitFunction p0,
         assert(def != NULL);
     }
 
+    /* Do anything else that should be done
+     * while still using the main interpreter. */
+    if (res.kind == _Py_ext_module_kind_SINGLEPHASE) {
+        /* Remember the filename as the __file__ attribute */
+        if (info->filename != NULL) {
+            if (PyModule_AddObjectRef(mod, "__file__", info->filename) < 0) {
+                PyErr_Clear(); /* Not important enough to report */
+            }
+        }
+
+        /* Update global import state. */
+        assert(def->m_base.m_index != 0);
+        struct singlephase_global_update singlephase = {
+            // XXX Modules that share a def should each get their own index,
+            // whereas currently they share (which means the per-interpreter
+            // cache is less reliable than it should be).
+            .m_index=def->m_base.m_index,
+            .origin=info->origin,
+        };
+        // gh-88216: Extensions and def->m_base.m_copy can be updated
+        // when the extension module doesn't support sub-interpreters.
+        if (def->m_size == -1) {
+            /* We will reload from m_copy. */
+            assert(def->m_base.m_init == NULL);
+            singlephase.m_dict = PyModule_GetDict(mod);
+            assert(singlephase.m_dict != NULL);
+        }
+        else {
+            /* We will reload via the init function. */
+            assert(def->m_size >= 0);
+            assert(def->m_base.m_copy == NULL);
+            singlephase.m_init = p0;
+        }
+        cached = update_global_state_for_extension(
+                tstate, info->path, info->name, def, &singlephase);
+        if (cached == NULL) {
+            goto error;
+        }
+    }
+
     /* Switch back to the subinterpreter. */
     if (main_tstate != tstate) {
         /* Any module we got from the init function will have to be
@@ -2003,63 +2043,31 @@ import_run_extension(PyThreadState *tstate, PyModInitFunction p0,
         if (_PyImport_CheckSubinterpIncompatibleExtensionAllowed(name_buf) < 0) {
             goto error;
         }
-        assert(mod != NULL);
-        assert(PyModule_Check(mod));
-
-        /* Remember the filename as the __file__ attribute */
-        if (info->filename != NULL) {
-            if (PyModule_AddObjectRef(mod, "__file__", info->filename) < 0) {
-                PyErr_Clear(); /* Not important enough to report */
-            }
-        }
-
-        /* Update global import state. */
-        assert(def->m_base.m_index != 0);
-        struct singlephase_global_update singlephase = {
-            // XXX Modules that share a def should each get their own index,
-            // whereas currently they share (which means the per-interpreter
-            // cache is less reliable than it should be).
-            .m_index=def->m_base.m_index,
-            .origin=info->origin,
-        };
-        // gh-88216: Extensions and def->m_base.m_copy can be updated
-        // when the extension module doesn't support sub-interpreters.
-        if (def->m_size == -1) {
-            /* We will reload from m_copy. */
-            assert(def->m_base.m_init == NULL);
-            singlephase.m_dict = PyModule_GetDict(mod);
-            assert(singlephase.m_dict != NULL);
-        }
-        else {
-            /* We will reload via the init function. */
-            assert(def->m_size >= 0);
-            assert(def->m_base.m_copy == NULL);
-            singlephase.m_init = p0;
-        }
-        cached = update_global_state_for_extension(
-                tstate, info->path, info->name, def, &singlephase);
-        if (cached == NULL) {
-            goto error;
-        }
+        assert(!PyErr_Occurred());
 
         if (main_tstate != tstate) {
             /* We switched to the main interpreter to run the init
              * function, so now we will "reload" the module from the
              * cached data using the original subinterpreter. */
-            Py_CLEAR(mod);
+            assert(mod == NULL);
             mod = reload_singlephase_extension(tstate, cached, info);
             if (mod == NULL) {
                 goto error;
             }
+            assert(!PyErr_Occurred());
+            assert(PyModule_Check(mod));
         }
-        assert(!PyErr_Occurred());
-
-        /* Update per-interpreter import state. */
-        PyObject *modules = get_modules_dict(tstate, true);
-        if (finish_singlephase_extension(
-                tstate, mod, cached, info->name, modules) < 0)
-        {
-            goto error;
+        else {
+            assert(mod != NULL);
+            assert(PyModule_Check(mod));
+
+            /* Update per-interpreter import state. */
+            PyObject *modules = get_modules_dict(tstate, true);
+            if (finish_singlephase_extension(
+                    tstate, mod, cached, info->name, modules) < 0)
+            {
+                goto error;
+            }
         }
     }