Add path_finder.SUPPORTED_LIBNAMES (#558)

* Revert "Reapply "Revert debug changes under .github/workflows""

This reverts commit 8f69f83.

* Add names of all CTK 12.8.1 x86_64-linux libraries (.so) as `path_finder.SUPPORTED_LIBNAMES`

https://chatgpt.com/share/67f98d0b-148c-8008-9951-9995cf5d860c

* Add `SUPPORTED_WINDOWS_DLLS`

* Add copyright notice

* Move SUPPORTED_LIBNAMES, SUPPORTED_WINDOWS_DLLS to _path_finder/supported_libs.py

* Use SUPPORTED_WINDOWS_DLLS in _windows_load_with_dll_basename()

* Change "Set up mini CTK" to use `method: local`, remove `sub-packages` line.

* Use Jimver/[email protected] also under Linux, `method: local`, no `sub-packages`.

* Add more `nvidia-*-cu12` wheels to get as many of the supported shared libraries as possible.

* Revert "Use Jimver/[email protected] also under Linux, `method: local`, no `sub-packages`."

This reverts commit d499806.

Problem observed:

```
/usr/bin/docker exec  1b42cd4ea3149ac3f2448eae830190ee62289b7304a73f8001e90cead5005102 sh -c "cat /etc/*release | grep ^ID"
Warning: Failed to restore: Cache service responded with 422
/usr/bin/tar --posix -cf cache.tgz --exclude cache.tgz -P -C /__w/cuda-python/cuda-python --files-from manifest.txt -z
Failed to save: Unable to reserve cache with key cuda_installer-linux-5.15.0-135-generic-x64-12.8.0, another job may be creating this cache. More details: This legacy service is shutting down, effective April 15, 2025. Migrate to the new service ASAP. For more information: https://gh.io/gha-cache-sunset
Warning: Error during installation: Error: Unable to locate executable file: sudo. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.
Error: Error: Unable to locate executable file: sudo. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.
```

* Change test_path_finder::test_find_and_load() to skip cufile on Windows, and report exceptions as failures, except for cudart

* Add nvidia-cuda-runtime-cu12 to pyproject.toml (for libname cudart)

* test_path_finder.py: before loading cusolver, load nvJitLink, cusparse, cublas (experiment to see if that resolves the only Windows failure)

Test (win-64, Python 3.12, CUDA 12.8.0, Runner default, CTK wheels) / test

```
================================== FAILURES ===================================
________________________ test_find_and_load[cusolver] _________________________

libname = 'cusolver'

    @pytest.mark.parametrize("libname", path_finder.SUPPORTED_LIBNAMES)
    def test_find_and_load(libname):
        if sys.platform == "win32" and libname == "cufile":
            pytest.skip(f'test_find_and_load("{libname}") not supported on this platform')
        print(f'\ntest_find_and_load("{libname}")')
        failures = []
        for algo, func in (
            ("find", path_finder.find_nvidia_dynamic_library),
            ("load", path_finder.load_nvidia_dynamic_library),
        ):
            try:
                out = func(libname)
            except Exception as e:
                out = f"EXCEPTION: {type(e)} {str(e)}"
                failures.append(algo)
            print(out)
        print()
>       assert not failures
E       AssertionError: assert not ['load']

tests\test_path_finder.py:29: AssertionError
```

* test_path_finder.py: load *only* nvJitLink before loading cusolver

* Run each test_find_or_load_nvidia_dynamic_library() subtest in a subprocess

* Add cublasLt to supported_libs.py and load deps for cusolver, cusolverMg, cusparse in test_path_finder.py. Also restrict test_path_finder.py to test load only for now.

* Add supported_libs.DIRECT_DEPENDENCIES

* Remove cufile_rdma from supported libs (comment out).

https://chatgpt.com/share/68033a33-385c-8008-a293-4c8cc3ea23ae

* Split out `PARTIALLY_SUPPORTED_LIBNAMES`. Fix up test code.

* Reduce public API to only load_nvidia_dynamic_library, SUPPORTED_LIBNAMES

* Set CUDA_BINDINGS_PATH_FINDER_TEST_ALL_LIBNAMES=1 to match expected availability of nvidia shared libraries.

* Refactor as `class _find_nvidia_dynamic_library`

* Strict wheel, conda, system rule: try using the platform-specific dynamic loader search mechanisms only last

* Introduce _load_and_report_path_linux(), add supported_libs.EXPECTED_LIB_SYMBOLS

* Plug in ctypes.windll.kernel32.GetModuleFileNameW()

* Keep track of nvrtc-related GitHub comment

* Factor out `_find_dll_under_dir(dirpath, file_wild)` and reuse from `_find_dll_using_nvidia_bin_dirs()`, `_find_dll_using_cudalib_dir()` (to fix loading nvrtc64_120_0.dll from local CTK)

* Minimal "is already loaded" code.

* Add THIS FILE NEEDS TO BE REVIEWED/UPDATED FOR EACH CTK RELEASE comment in _path_finder/supported_libs.py

* Add SUPPORTED_LINUX_SONAMES in _path_finder/supported_libs.py

* Update SUPPORTED_WINDOWS_DLLS in _path_finder/supported_libs.py based on DLLs found in cuda_*win*.exe files.

* Remove `os.add_dll_directory()` and `os.environ["PATH"]` manipulations from find_nvidia_dynamic_library.py. Add `supported_libs.LIBNAMES_REQUIRING_OS_ADD_DLL_DIRECTORY` and use from `load_nvidia_dynamic_library()`.

* Move nvrtc-specific code from find_nvidia_dynamic_library.py to `supported_libs.is_suppressed_dll_file()`

* Introduce dataclass LoadedDL as return type for load_nvidia_dynamic_library()

* Factor out _abs_path_for_dynamic_library_* and use on handle obtained through "is already loaded" checks

* Factor out _load_nvidia_dynamic_library_no_cache() and use for exercising LoadedDL.was_already_loaded_from_elsewhere

* _check_nvjitlink_usable() in test_path_finder.py

* Undo changes in .github/workflows/ and cuda_bindings/pyproject.toml

* Move cuda_bindings/tests/path_finder.py -> toolshed/run_cuda_bindings_path_finder.py

* Add bandit suppressions in test_path_finder.py

* Add pytest info_summary_append fixture and use from test_path_finder.py to report the absolute paths of the loaded libraries.

Author: rwgk

cuda_bindings/cuda/bindings/_bindings/cynvrtc.pyx.in

@@ -56,7 +56,7 @@ cdef int cuPythonInit() except -1 nogil:
 
     {{if 'Windows' == platform.system()}}
     with gil:
-        handle = path_finder.load_nvidia_dynamic_library("nvrtc")
+        handle = path_finder.load_nvidia_dynamic_library("nvrtc").handle
         {{if 'nvrtcGetErrorString' in found_functions}}
         try:
             global __nvrtcGetErrorString
@@ -242,7 +242,7 @@ cdef int cuPythonInit() except -1 nogil:
 
     {{else}}
     with gil:
-        handle = <void*><uintptr_t>path_finder.load_nvidia_dynamic_library("nvrtc")
+        handle = <void*><uintptr_t>path_finder.load_nvidia_dynamic_library("nvrtc").handle
     {{if 'nvrtcGetErrorString' in found_functions}}
     global __nvrtcGetErrorString
     __nvrtcGetErrorString = dlfcn.dlsym(handle, 'nvrtcGetErrorString')

cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx

@@ -53,7 +53,7 @@ cdef void* __nvJitLinkVersion = NULL
 
 
 cdef void* load_library(int driver_ver) except* with gil:
-    cdef uintptr_t handle = path_finder.load_nvidia_dynamic_library("nvJitLink")
+    cdef uintptr_t handle = path_finder.load_nvidia_dynamic_library("nvJitLink").handle
     return <void*>handle
 
 

cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx

@@ -40,7 +40,7 @@ cdef void* __nvJitLinkVersion = NULL
 
 
 cdef void* load_library(int driver_ver) except* with gil:
-    cdef intptr_t handle = path_finder.load_nvidia_dynamic_library("nvJitLink")
+    cdef intptr_t handle = path_finder.load_nvidia_dynamic_library("nvJitLink").handle
     return <void*>handle
 
 

cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx

@@ -51,7 +51,7 @@ cdef void* __nvvmGetProgramLog = NULL
 
 
 cdef void* load_library(const int driver_ver) except* with gil:
-    cdef uintptr_t handle = path_finder.load_nvidia_dynamic_library("nvvm")
+    cdef uintptr_t handle = path_finder.load_nvidia_dynamic_library("nvvm").handle
     return <void*>handle
 
 

cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx

@@ -38,7 +38,7 @@ cdef void* __nvvmGetProgramLog = NULL
 
 
 cdef void* load_library(int driver_ver) except* with gil:
-    cdef intptr_t handle = path_finder.load_nvidia_dynamic_library("nvvm")
+    cdef intptr_t handle = path_finder.load_nvidia_dynamic_library("nvvm").handle
     return <void*>handle
 
 

cuda_bindings/cuda/bindings/_path_finder/find_nvidia_dynamic_library.py

@@ -7,6 +7,7 @@
 import os
 
 from .cuda_paths import IS_WIN32, get_cuda_paths
+from .supported_libs import is_suppressed_dll_file
 from .sys_path_find_sub_dirs import sys_path_find_sub_dirs
 
 
@@ -38,9 +39,13 @@ def _find_so_using_nvidia_lib_dirs(libname, so_basename, error_messages, attachm
     return None
 
 
-def _append_to_os_environ_path(dirpath):
-    curr_path = os.environ.get("PATH")
-    os.environ["PATH"] = dirpath if curr_path is None else os.pathsep.join((curr_path, dirpath))
+def _find_dll_under_dir(dirpath, file_wild):
+    for path in sorted(glob.glob(os.path.join(dirpath, file_wild))):
+        if not os.path.isfile(path):
+            continue
+        if not is_suppressed_dll_file(os.path.basename(path)):
+            return path
+    return None
 
 
 def _find_dll_using_nvidia_bin_dirs(libname, error_messages, attachments):
@@ -50,30 +55,8 @@ def _find_dll_using_nvidia_bin_dirs(libname, error_messages, attachments):
         nvidia_sub_dirs = ("nvidia", "*", "bin")
     file_wild = libname + "*.dll"
     for bin_dir in sys_path_find_sub_dirs(nvidia_sub_dirs):
-        dll_name = None
-        have_builtins = False
-        for path in sorted(glob.glob(os.path.join(bin_dir, file_wild))):
-            # nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-win_amd64.whl:
-            #     nvidia\cuda_nvrtc\bin\
-            #         nvrtc-builtins64_128.dll
-            #         nvrtc64_120_0.alt.dll
-            #         nvrtc64_120_0.dll
-            node = os.path.basename(path)
-            if node.endswith(".alt.dll"):
-                continue
-            if "-builtins" in node:
-                have_builtins = True
-                continue
-            if dll_name is not None:
-                continue
-            if os.path.isfile(path):
-                dll_name = path
+        dll_name = _find_dll_under_dir(bin_dir, file_wild)
         if dll_name is not None:
-            if have_builtins:
-                # Add the DLL directory to the search path
-                os.add_dll_directory(bin_dir)
-                # Update PATH as a fallback for dependent DLL resolution
-                _append_to_os_environ_path(bin_dir)
             return dll_name
     _no_such_file_in_sub_dirs(nvidia_sub_dirs, file_wild, error_messages, attachments)
     return None
@@ -122,41 +105,52 @@ def _find_dll_using_cudalib_dir(libname, error_messages, attachments):
     if cudalib_dir is None:
         return None
     file_wild = libname + "*.dll"
-    for dll_name in sorted(glob.glob(os.path.join(cudalib_dir, file_wild))):
-        if os.path.isfile(dll_name):
-            return dll_name
+    dll_name = _find_dll_under_dir(cudalib_dir, file_wild)
+    if dll_name is not None:
+        return dll_name
     error_messages.append(f"No such file: {file_wild}")
     attachments.append(f'  listdir("{cudalib_dir}"):')
     for node in sorted(os.listdir(cudalib_dir)):
         attachments.append(f"    {node}")
     return None
 
 
-@functools.cache
-def find_nvidia_dynamic_library(name: str) -> str:
-    error_messages = []
-    attachments = []
-
-    if IS_WIN32:
-        dll_name = _find_dll_using_nvidia_bin_dirs(name, error_messages, attachments)
-        if dll_name is None:
-            if name == "nvvm":
-                dll_name = _get_cuda_paths_info("nvvm", error_messages)
-            else:
-                dll_name = _find_dll_using_cudalib_dir(name, error_messages, attachments)
-        if dll_name is None:
-            attachments = "\n".join(attachments)
-            raise RuntimeError(f'Failure finding "{name}*.dll": {", ".join(error_messages)}\n{attachments}')
-        return dll_name
-
-    so_basename = f"lib{name}.so"
-    so_name = _find_so_using_nvidia_lib_dirs(name, so_basename, error_messages, attachments)
-    if so_name is None:
-        if name == "nvvm":
-            so_name = _get_cuda_paths_info("nvvm", error_messages)
+class _find_nvidia_dynamic_library:
+    def __init__(self, libname: str):
+        self.libname = libname
+        self.error_messages = []
+        self.attachments = []
+        self.abs_path = None
+
+        if IS_WIN32:
+            self.abs_path = _find_dll_using_nvidia_bin_dirs(libname, self.error_messages, self.attachments)
+            if self.abs_path is None:
+                if libname == "nvvm":
+                    self.abs_path = _get_cuda_paths_info("nvvm", self.error_messages)
+                else:
+                    self.abs_path = _find_dll_using_cudalib_dir(libname, self.error_messages, self.attachments)
+            self.lib_searched_for = f"{libname}*.dll"
         else:
-            so_name = _find_so_using_cudalib_dir(so_basename, error_messages, attachments)
-    if so_name is None:
-        attachments = "\n".join(attachments)
-        raise RuntimeError(f'Failure finding "{so_basename}": {", ".join(error_messages)}\n{attachments}')
-    return so_name
+            self.lib_searched_for = f"lib{libname}.so"
+            self.abs_path = _find_so_using_nvidia_lib_dirs(
+                libname, self.lib_searched_for, self.error_messages, self.attachments
+            )
+            if self.abs_path is None:
+                if libname == "nvvm":
+                    self.abs_path = _get_cuda_paths_info("nvvm", self.error_messages)
+                else:
+                    self.abs_path = _find_so_using_cudalib_dir(
+                        self.lib_searched_for, self.error_messages, self.attachments
+                    )
+
+    def raise_if_abs_path_is_None(self):
+        if self.abs_path:
+            return self.abs_path
+        err = ", ".join(self.error_messages)
+        att = "\n".join(self.attachments)
+        raise RuntimeError(f'Failure finding "{self.lib_searched_for}": {err}\n{att}')
+
+
+@functools.cache
+def find_nvidia_dynamic_library(libname: str) -> str:
+    return _find_nvidia_dynamic_library(libname).raise_if_abs_path_is_None()