Port the reification cache to the current resolution code

Lazy import resolution moved to Objects/lazyimportobject.c and no longer
holds the global import lock, so store the result with an atomic
compare-and-swap: concurrent resolutions of one proxy return the first
result that was stored. Clarify the docs and test concurrent resolve().

Author: brittanyrey

Doc/library/types.rst

@@ -358,9 +358,9 @@ Standard names are defined for the following types:
 
       Reify the lazy import and return the "real" object being imported.
 
-      A lazy import is successfully reified at most once.  Repeated calls, and any later
-      access to a name still bound to the proxy, return the object from the
-      first reification, even if the module has since been removed from
+      Once a lazy import has been reified successfully, repeated calls, and
+      any later access to a name still bound to the proxy, return the same
+      object, even if the module has since been removed from
       :data:`sys.modules`.  A reification that raises is not remembered, so
       the next access retries the import.
 

Lib/test/test_lazy_import/__init__.py

@@ -13,6 +13,7 @@
 import contextlib
 
 from test import support
+from test.support import threading_helper
 from test.support.script_helper import assert_python_ok, assert_python_failure
 
 try:
@@ -365,6 +366,29 @@ def main():
             main()
         """)
 
+    @threading_helper.requires_working_threading()
+    def test_concurrent_resolve_returns_one_object(self):
+        """Concurrent reifications of one proxy all return the same object."""
+        import builtins
+        ns = {"__builtins__": {
+            "__lazy_import__": builtins.__lazy_import__,
+            "__import__": lambda name, *args: types.ModuleType(name),
+        }}
+        exec("lazy import target_module", ns)
+        proxy = ns["target_module"]
+        barrier = threading.Barrier(8)
+        results = []
+
+        def worker():
+            barrier.wait()
+            results.append(proxy.resolve())
+
+        with threading_helper.start_threads(
+                threading.Thread(target=worker) for _ in range(8)):
+            pass
+        self.assertEqual(len(results), 8)
+        self.assertTrue(all(r is results[0] for r in results))
+
     @support.requires_subprocess()
     def test_from_import_proxy_remembers_the_attribute(self):
         """A `lazy from` proxy binds the attribute, not the module."""

Objects/lazyimportobject.c

@@ -23,6 +23,8 @@ typedef struct {
     // in lz_from, and the attribute to import from (PyUnicode) it in lz_attr.
     PyObject *lz_from;
     PyObject *lz_attr;
+    // Result of the first successful resolution, or NULL.
+    PyObject *lz_resolved;
     // Declaration location.
     PyCodeObject *lz_code;
     int lz_instr_offset;
@@ -70,6 +72,7 @@ _PyLazyImport_New(_PyInterpreterFrame *frame, PyObject *builtins,
     m->lz_builtins = Py_XNewRef(builtins);
     m->lz_from = Py_NewRef(name);
     m->lz_attr = Py_XNewRef(fromlist);
+    m->lz_resolved = NULL;
 
     m->lz_code = NULL;
     m->lz_instr_offset = -1;
@@ -156,6 +159,7 @@ lazy_import_traverse(PyObject *op, visitproc visit, void *arg)
     Py_VISIT(m->lz_builtins);
     Py_VISIT(m->lz_from);
     Py_VISIT(m->lz_attr);
+    Py_VISIT(m->lz_resolved);
     Py_VISIT(m->lz_code);
     return 0;
 }
@@ -167,6 +171,7 @@ lazy_import_clear(PyObject *op)
     Py_CLEAR(m->lz_builtins);
     Py_CLEAR(m->lz_from);
     Py_CLEAR(m->lz_attr);
+    Py_CLEAR(m->lz_resolved);
     Py_CLEAR(m->lz_code);
     return 0;
 }
@@ -368,6 +373,10 @@ lazy_import_resolve_impl(PyThreadState *tstate, PyObject *lazy_import,
     assert(PyLazyImport_CheckExact(lazy_import));
 
     PyLazyImportObject *lz = (PyLazyImportObject *)lazy_import;
+    PyObject *resolved = FT_ATOMIC_LOAD_PTR_ACQUIRE(lz->lz_resolved);
+    if (resolved != NULL) {
+        return Py_NewRef(resolved);
+    }
 
     // Walk back to the placeholder IMPORT_NAME left, and the first lookup on it.
     PyLazyImportObject *root = lz, *first = NULL;
@@ -535,6 +544,15 @@ lazy_import_resolve_impl(PyThreadState *tstate, PyObject *lazy_import,
         }
         Py_XDECREF(name);
     }
+    if (obj != NULL) {
+        // Concurrent resolutions return the first result that was stored.
+        PyObject *expected = NULL;
+        if (!_Py_atomic_compare_exchange_ptr(&lz->lz_resolved, &expected,
+                                             Py_NewRef(obj))) {
+            Py_DECREF(obj);
+            Py_SETREF(obj, Py_NewRef(expected));
+        }
+    }
     if (resolving != NULL) {
         // A failed set resize can leave the placeholder inserted. Removing by
         // identity also permits greenlets to finish in a different order.