Update

[ghstack-poisoned]

Author: shoumikhin

.ci/scripts/wheel/test_cpp_sdk.py

@@ -130,20 +130,56 @@
 # environment or the separate nvidia packages. None is reachable from an ldd process,
 # and a wheel must not carry an absolute path to a build machine's copy just to
 # satisfy a check. Anything the wheel itself ships still has to resolve.
-_EXTERNAL_LIBRARY_PREFIXES = (
-    "libpython",
-    "libtorch",
-    "libc10",
-    "libcuda",
-    "libcurand",
-    "libcublas",
-    "libnvinfer",
+# Base names of the libraries the wheel expects from outside itself: the interpreter,
+# PyTorch, and the CUDA runtime. Matched as whole names rather than as prefixes, because a
+# prefix test also excuses unrelated libraries that merely start the same way, such as
+# libtorchcodec_core.so or libcudagraph_helper.so.
+_EXTERNAL_LIBRARY_NAMES = frozenset(
+    {
+        "libpython3",
+        "libtorch",
+        "libtorch_cpu",
+        "libtorch_cuda",
+        "libtorch_python",
+        "libtorch_global_deps",
+        "libc10",
+        "libc10_cuda",
+        "libcuda",
+        "libcudart",
+        "libcurand",
+        "libcublas",
+        "libcublasLt",
+        "libcudnn",
+        "libcufft",
+        "libcusparse",
+        "libcusolver",
+        "libnvinfer",
+        "libnvinfer_plugin",
+        "libnvrtc",
+        "libnccl",
+    }
+)
+
+# The CUDA entry points, spelled the way the CUDA APIs are: a known family followed by an
+# uppercase letter. A bare "cu" prefix would also suppress ordinary names such as
+# custom_double_out, so a library genuinely missing one would pass unnoticed.
+_CUDA_SYMBOL = re.compile(
+    r"undefined symbol:\s+_*(?:"
+    r"cuda[A-Z]|cu[A-Z]|curand[A-Z]|cublas[A-Z]|cudnn[A-Z]"
+    r"|cusparse[A-Z]|cusolver[A-Z]|cufft[A-Z]|nvrtc[A-Z]|nccl[A-Z]"
+    r")"
 )
 
+_SONAME_SUFFIX = re.compile(r"\.so(?:\.\d+)*$")
+
 
 def _provided_externally(name: str) -> bool:
     """Whether a shared library is expected to come from outside the wheel."""
-    return name.startswith(_EXTERNAL_LIBRARY_PREFIXES)
+    base = _SONAME_SUFFIX.sub("", name)
+    if base in _EXTERNAL_LIBRARY_NAMES:
+        return True
+    # Version-suffixed interpreter names such as libpython3.12.
+    return bool(re.fullmatch(r"libpython3(?:\.\d+)?", base))
 
 
 # The component library each target is expected to expose. Keyed by the library base
@@ -317,9 +353,7 @@ def test_shipped_libraries_load() -> None:
             # __cudaRegisterFatBinary for every compiled .cu file.
             and not (
                 skip_undefined
-                and re.search(
-                    r"undefined symbol:\s+_*(cu|cuda|curand|cublas|cudnn)", line
-                )
+                and re.search(_CUDA_SYMBOL, line)
             )
         ]
         if undefined:

extension/cuda/CMakeLists.txt

@@ -32,6 +32,20 @@ target_compile_definitions(
   extension_cuda PRIVATE EXECUTORCH_EXTENSION_CUDA_BUILDING
 )
 
+if(EXECUTORCH_BUILD_SHARED)
+  # A namespaced, versioned name, matching the other libraries the wheel ships. The CUDA
+  # delegate carries a real symbol reference to this library, so its DT_NEEDED entry
+  # survives even under --as-needed. A generic name like libextension_cuda.so could be
+  # satisfied by an unrelated library that happens to be loaded first, which would bind a
+  # different caller-stream implementation into the delegate.
+  set_target_properties(
+    extension_cuda
+    PROPERTIES OUTPUT_NAME executorch_extension_cuda
+               VERSION "${PROJECT_VERSION}"
+               SOVERSION "${PROJECT_VERSION_MAJOR}"
+  )
+endif()
+
 install(
   TARGETS extension_cuda
   EXPORT ExecuTorchTargets

setup.py

@@ -1310,11 +1310,19 @@ def run(self):  # noqa C901
                 # whenever CUDA is on, so gating on the shared runtime as well
                 # would drop it from a CUDA wheel built with a static runtime.
                 BuiltFile(
-                    src_dir="%CMAKE_CACHE_DIR%/extension/cuda/%BUILD_TYPE%/",
-                    src_name="extension_cuda",
-                    dst="executorch/lib/",
-                    is_dynamic_lib=True,
-                    dependent_cmake_flags=["EXECUTORCH_BUILD_CUDA"],
+                    src_dir="%CMAKE_CACHE_DIR%/extension/cuda/",
+                    src_name=(
+                        "libexecutorch_extension_cuda.so."
+                        f"{get_runtime_soname_major()}.*"
+                    ),
+                    dst=(
+                        "executorch/lib/libexecutorch_extension_cuda.so."
+                        f"{get_runtime_soname_major()}"
+                    ),
+                    dependent_cmake_flags=[
+                        "EXECUTORCH_BUILD_SHARED",
+                        "EXECUTORCH_BUILD_CUDA",
+                    ],
                 ),
                 # Install the prebuilt pybindings extension wrapper for the runtime,
                 # portable kernels, and a selection of backends. This lets users