Merge branch 'path_finder_search_priority_v2' into path_finder_search_priority_v2_use_in_bindings

Author: rwgk

cuda_bindings/cuda/bindings/_path_finder/load_dl_common.py

@@ -1,11 +1,10 @@
 # Copyright 2025 NVIDIA Corporation.  All rights reserved.
 # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
 
-import subprocess  # nosec B404
-import sys
 from dataclasses import dataclass
 from typing import Callable, Optional
 
+from cuda.bindings._path_finder.run_python_code_safely import run_python_code_safely
 from cuda.bindings._path_finder.supported_libs import DIRECT_DEPENDENCIES
 
 
@@ -44,12 +43,7 @@ def load_dependencies(libname: str, load_func: Callable[[str], LoadedDL]) -> Non
 
 def load_in_subprocess(python_code, timeout=30):
     # This is to avoid loading libraries into the parent process.
-    return subprocess.run(  # nosec B603
-        [sys.executable, "-c", python_code],
-        capture_output=True,
-        encoding="utf-8",
-        timeout=timeout,  # Ensure this does not hang for an excessive amount of time.
-    )
+    return run_python_code_safely(python_code, timeout=timeout)
 
 
 def build_subprocess_failed_for_libname_message(libname, result):

cuda_bindings/cuda/bindings/_path_finder/run_python_code_safely.py

@@ -0,0 +1,84 @@
+import multiprocessing
+import subprocess  # nosec B404
+import sys
+import traceback
+from io import StringIO
+
+
+class Worker:
+    def __init__(self, python_code, result_queue):
+        self.python_code = python_code
+        self.result_queue = result_queue
+
+    def __call__(self):
+        # Capture stdout/stderr
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        sys.stdout = StringIO()
+        sys.stderr = StringIO()
+
+        try:
+            exec(self.python_code, {"__name__": "__main__"})  # nosec B102
+            returncode = 0
+        except SystemExit as e:  # Handle sys.exit()
+            returncode = e.code if isinstance(e.code, int) else 0
+        except BaseException:
+            traceback.print_exc()
+            returncode = 1
+        finally:
+            # Collect outputs and restore streams
+            stdout = sys.stdout.getvalue()
+            stderr = sys.stderr.getvalue()
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+            try:  # noqa: SIM105
+                self.result_queue.put((returncode, stdout, stderr))
+            except Exception:  # nosec B110
+                # If the queue is broken (e.g., parent gone), best effort logging
+                pass
+
+
+def run_python_code_safely(python_code, *, timeout=None):
+    """Run Python code in a spawned subprocess, capturing stdout/stderr/output."""
+    ctx = multiprocessing.get_context("spawn")
+    result_queue = ctx.SimpleQueue()
+    process = ctx.Process(target=Worker(python_code, result_queue))
+    process.start()
+
+    try:
+        process.join(timeout)
+        if process.is_alive():
+            process.terminate()
+            process.join()
+            return subprocess.CompletedProcess(
+                args=[sys.executable, "-c", python_code],
+                returncode=-9,
+                stdout="",
+                stderr=f"Process timed out after {timeout} seconds and was terminated.",
+            )
+
+        if result_queue.empty():
+            return subprocess.CompletedProcess(
+                args=[sys.executable, "-c", python_code],
+                returncode=-999,
+                stdout="",
+                stderr="Process exited without returning results.",
+            )
+
+        returncode, stdout, stderr = result_queue.get()
+        return subprocess.CompletedProcess(
+            args=[sys.executable, "-c", python_code],
+            returncode=returncode,
+            stdout=stdout,
+            stderr=stderr,
+        )
+
+    finally:
+        try:
+            result_queue.close()
+            result_queue.join_thread()
+        except Exception:  # nosec B110
+            pass
+        if process.is_alive():
+            process.kill()
+            process.join()

cuda_bindings/docs/source/release/12.9.0-notes.rst

@@ -15,13 +15,13 @@ Highlights
 * Statically link CUDA Runtime instead of reimplementing it
 * Move stream callback wrappers to the Python layer
 * Return code construction is made faster
-* Failed API calls return None for non error code tuple elements
 
 
 Bug fixes
 ---------
 
 * Fix segfault when converting char* NULL to bytes
+* Failed API calls return None for non error code tuple elements
 * Compute-sanitizer may report ``CUDA_ERROR_INVALID_CONTEXT`` when calling certain CUDA
   runtime APIs such as ``cudaGetDevice()``
 

cuda_bindings/docs/versions.json

@@ -1,5 +1,6 @@
 {
     "latest"  : "latest",
+    "12.9.0"  : "12.9.0",
     "12.8.0"  : "12.8.0",
     "12.6.2"  : "12.6.2",
     "12.6.1"  : "12.6.1"

cuda_core/docs/source/install.md

@@ -7,13 +7,14 @@ dependencies are as follows:
 
 |                   | CUDA 11      | CUDA 12     |
 |------------------ | ------------ | ----------- |
-| CUDA Toolkit [^1] | 11.2 - 11.8  | 12.0 - 12.6 |
+| CUDA Toolkit [^1] | 11.2 - 11.8  | 12.x        |
 | Driver            | 450.80.02+ (Linux), 452.39+ (Windows) | 525.60.13+ (Linux), 527.41+ (Windows) |
 
 [^1]: Including `cuda-python`.
 
 `cuda.core` supports Python 3.9 - 3.13, on Linux (x86-64, arm64) and Windows (x86-64).
 
+
 ## Installing from PyPI
 
 `cuda.core` works with `cuda.bindings` (part of `cuda-python`) 11 or 12. For example with CUDA 12:
@@ -22,8 +23,9 @@ $ pip install cuda-core[cu12]
 ```
 and likewise use `[cu11]` for CUDA 11.
 
-Note that using `cuda.core` with NVRTC or nvJitLink installed from PyPI via `pip install` requires
-`cuda.bindings` 12.8.0+ or 11.8.6+.
+Note that using `cuda.core` with NVRTC installed from PyPI via `pip install` requires
+`cuda.bindings` 12.8.0+ or 11.8.6+. Likewise, with nvJitLink it requires 12.8.0+.
+
 
 ## Installing from Conda (conda-forge)
 
@@ -33,12 +35,8 @@ $ conda install -c conda-forge cuda-core cuda-version=12
 ```
 and likewise use `cuda-version=11` for CUDA 11.
 
-Note that to use `cuda.core` with nvJitLink installed from conda-forge currently requires it to
-be separately installed:
-```console
-$ conda install -c conda-forge libnvjitlink
-```
-(can be combined with the command above). This extra step will be removed in a future release.
+Note that to use `cuda.core` with nvJitLink installed from conda-forge requires `cuda.bindings` 12.8.0+.
+
 
 ## Installing from Source
 
@@ -47,4 +45,4 @@ $ git clone https://github.com/NVIDIA/cuda-python
 $ cd cuda-python/cuda_core
 $ pip install .
 ```
-For now `cuda-python` (`cuda-bindings` later) 11.x or 12.x is a required dependency.
+`cuda-bindings` 11.x or 12.x is a required dependency.

cuda_python/docs/source/release.md

@@ -5,6 +5,7 @@
 maxdepth: 3
 ---
 
+    12.9.0 <release/12.9.0-notes>
     12.8.0 <release/12.8.0-notes>
     12.6.2 <release/12.6.2-notes>
     12.6.1 <release/12.6.1-notes>

cuda_python/docs/source/release/12.9.0-notes.rst

@@ -0,0 +1,18 @@
+.. SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# CUDA Python 12.9.0 Release notes
+==================================
+
+Released on May 5, 2025.
+
+
+Included components
+-------------------
+
+* `cuda.bindings 12.9.0 <https://nvidia.github.io/cuda-python/cuda-bindings/12.9.0/release/12.9.0-notes.html>`_
+
+
+Highlights
+----------
+
+* Add bindings for libNVVM

cuda_python/docs/versions.json

@@ -1,5 +1,6 @@
 {
     "latest"  : "latest",
+    "12.9.0"  : "12.9.0",
     "12.8.0"  : "12.8.0",
     "12.6.2"  : "12.6.2",
     "12.6.1"  : "12.6.1"