Merge branch 'main' into restricted-paths-guard_addl_collaborator_check

Author: rwgk

.github/workflows/ci.yml

@@ -121,7 +121,15 @@ jobs:
         id: filter
         if: ${{ startsWith(github.ref_name, 'pull-request/') }}
         env:
-          BASE_REF: ${{ fromJSON(steps.pr-info.outputs.pr-info).base.ref }}
+          # GitHub Actions evaluates step-level `env:` expressions eagerly —
+          # the step's `if:` gate does NOT short-circuit them. On non-PR
+          # events (push/tag/schedule), `pr-info` is skipped and its outputs
+          # are empty strings, so `fromJSON('')` would raise a template error
+          # and fail the step despite `if:` being false. Guard the
+          # `fromJSON` call with a short-circuit so the expression resolves
+          # to an empty string on non-PR events; the step is still gated
+          # off by `if:`, so `BASE_REF` is never consumed there.
+          BASE_REF: ${{ steps.pr-info.outputs.pr-info && fromJSON(steps.pr-info.outputs.pr-info).base.ref || '' }}
         run: |
           # Diff against the merge base with the PR's actual target branch.
           # Uses merge-base so diverged branches only show files changed on

cuda_bindings/cuda/bindings/utils/__init__.py

@@ -1,7 +1,8 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
 from typing import Any, Callable
 
+from ._nvvm_utils import check_nvvm_compiler_options
 from ._ptx_utils import get_minimal_required_cuda_ver_from_ptx_ver, get_ptx_ver
 from ._version_check import warn_if_cuda_major_version_mismatch
 

cuda_bindings/cuda/bindings/utils/_nvvm_utils.py

@@ -0,0 +1,89 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+from typing import Sequence
+
+_PRECHECK_NVVM_IR = """target triple = "nvptx64-unknown-cuda"
+target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-i128:128:128-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64"
+
+define void @dummy_kernel() {{
+entry:
+  ret void
+}}
+
+!nvvm.annotations = !{{!0}}
+!0 = !{{void ()* @dummy_kernel, !"kernel", i32 1}}
+
+!nvvmir.version = !{{!1}}
+!1 = !{{i32 {major}, i32 {minor}, i32 {debug_major}, i32 {debug_minor}}}
+"""
+
+
+def check_nvvm_compiler_options(options: Sequence[str]) -> bool:
+    """
+    Abstracted from https://github.com/NVIDIA/numba-cuda/pull/681
+
+    Check if the specified options are supported by the current libNVVM version.
+
+    The options are a list of strings, each representing a compiler option.
+
+    If the test program fails to compile, the options are not supported and False
+    is returned.
+
+    If the test program compiles successfully, True is returned.
+
+    cuda.bindings.nvvm returns exceptions instead of return codes.
+
+    Parameters
+    ----------
+    options : Sequence[str]
+        List of compiler options as strings (e.g., ["-arch=compute_90", "-g"]).
+
+    Returns
+    -------
+    bool
+        True if the options are supported, False otherwise.
+
+    Examples
+    --------
+    >>> from cuda.bindings.utils import check_nvvm_compiler_options
+    >>> check_nvvm_compiler_options(["-arch=compute_90", "-g"])
+    True
+    """
+    try:
+        from cuda.bindings import nvvm
+    except ModuleNotFoundError as exc:
+        if exc.name == "nvvm":
+            return False
+        raise
+
+    from cuda.bindings._internal.nvvm import _inspect_function_pointer
+
+    if _inspect_function_pointer("__nvvmCreateProgram") == 0:
+        return False
+
+    program = nvvm.create_program()
+    try:
+        major, minor, debug_major, debug_minor = nvvm.ir_version()
+        precheck_ir = _PRECHECK_NVVM_IR.format(
+            major=major,
+            minor=minor,
+            debug_major=debug_major,
+            debug_minor=debug_minor,
+        )
+        precheck_ir_bytes = precheck_ir.encode("utf-8")
+        nvvm.add_module_to_program(
+            program,
+            precheck_ir_bytes,
+            len(precheck_ir_bytes),
+            "precheck.ll",
+        )
+        try:
+            nvvm.compile_program(program, len(options), options)
+        except nvvm.nvvmError as e:
+            if e.status == nvvm.Result.ERROR_INVALID_OPTION:
+                return False
+            raise
+    finally:
+        nvvm.destroy_program(program)
+    return True

cuda_bindings/tests/test_utils.py

@@ -11,10 +11,29 @@
 
 from cuda.bindings import driver, runtime
 from cuda.bindings._internal.utils import get_c_compiler
-from cuda.bindings.utils import get_cuda_native_handle, get_minimal_required_cuda_ver_from_ptx_ver, get_ptx_ver
+from cuda.bindings.utils import (
+    check_nvvm_compiler_options,
+    get_cuda_native_handle,
+    get_minimal_required_cuda_ver_from_ptx_ver,
+    get_ptx_ver,
+)
 
 have_cufile = importlib.util.find_spec("cuda.bindings.cufile") is not None
 
+
+def _is_libnvvm_available() -> bool:
+    from cuda.bindings._internal.nvvm import _inspect_function_pointer
+    from cuda.pathfinder import DynamicLibNotFoundError
+
+    try:
+        return _inspect_function_pointer("__nvvmCreateProgram") != 0
+    except DynamicLibNotFoundError:
+        return False
+
+
+_libnvvm_available = _is_libnvvm_available()
+_skip_no_libnvvm = pytest.mark.skipif(not _libnvvm_available, reason="libNVVM not available")
+
 ptx_88_kernel = r"""
 .version 8.8
 .target sm_75
@@ -118,3 +137,35 @@ def test_get_c_compiler():
     c_compiler = get_c_compiler()
     prefix = ("GCC", "Clang", "MSVC", "Unknown")
     assert sum(c_compiler.startswith(p) for p in prefix) == 1
+
+
+@_skip_no_libnvvm
+def test_check_nvvm_compiler_options_valid():
+    assert check_nvvm_compiler_options(["-arch=compute_90"]) is True
+
+
+@_skip_no_libnvvm
+def test_check_nvvm_compiler_options_invalid():
+    assert check_nvvm_compiler_options(["--this-is-not-a-valid-option"]) is False
+
+
+@_skip_no_libnvvm
+def test_check_nvvm_compiler_options_empty():
+    assert check_nvvm_compiler_options([]) is True
+
+
+@_skip_no_libnvvm
+def test_check_nvvm_compiler_options_multiple_valid():
+    assert check_nvvm_compiler_options(["-arch=compute_90", "-opt=3", "-g"]) is True
+
+
+@_skip_no_libnvvm
+def test_check_nvvm_compiler_options_arch_detection():
+    assert check_nvvm_compiler_options(["-arch=compute_90"]) is True
+    assert check_nvvm_compiler_options(["-arch=compute_99999"]) is False
+
+
+def test_check_nvvm_compiler_options_no_libnvvm():
+    if _libnvvm_available:
+        pytest.skip("libNVVM is available; this test targets the fallback path")
+    assert check_nvvm_compiler_options(["-arch=compute_90"]) is False

cuda_core/cuda/core/__init__.py

@@ -4,37 +4,36 @@
 
 from cuda.core._version import __version__
 
-try:
+
+def _import_versioned_module():
+    import importlib
+
     from cuda import bindings
-except ImportError:
-    raise ImportError("cuda.bindings 12.x or 13.x must be installed") from None
-else:
-    cuda_major, cuda_minor = bindings.__version__.split(".")[:2]
+
+    cuda_major = bindings.__version__.split(".")[0]
     if cuda_major not in ("12", "13"):
         raise ImportError("cuda.bindings 12.x or 13.x must be installed")
 
-import importlib
+    subdir = f"cu{cuda_major}"
+    try:
+        versioned_mod = importlib.import_module(f".{subdir}", __package__)
+        # Import all symbols from the module
+        globals().update(versioned_mod.__dict__)
+    except ImportError:
+        # This is not a wheel build, but a conda or local build, do nothing
+        pass
+
+
+_import_versioned_module()
+del _import_versioned_module
 
-subdir = f"cu{cuda_major}"
-try:
-    versioned_mod = importlib.import_module(f".{subdir}", __package__)
-    # Import all symbols from the module
-    globals().update(versioned_mod.__dict__)
-except ImportError:
-    # This is not a wheel build, but a conda or local build, do nothing
-    pass
-else:
-    del versioned_mod
-finally:
-    del bindings, importlib, subdir, cuda_major, cuda_minor
 
 from cuda.core import system, utils
 from cuda.core._device import Device
 from cuda.core._event import Event, EventOptions
 from cuda.core._graphics import GraphicsResource
 from cuda.core._launch_config import LaunchConfig
 from cuda.core._launcher import launch
-from cuda.core._layout import _StridedLayout
 from cuda.core._linker import Linker, LinkerOptions
 from cuda.core._memory import (
     Buffer,

cuda_core/cuda/core/_device.pyx

@@ -1145,7 +1145,7 @@ class Device:
                 from cuda.core._memory import DeviceMemoryResource
                 self._memory_resource = DeviceMemoryResource(self._device_id)
             else:
-                from cuda.core._memory import _SynchronousMemoryResource
+                from cuda.core._memory._legacy import _SynchronousMemoryResource
                 self._memory_resource = _SynchronousMemoryResource(self._device_id)
 
         return self._memory_resource

cuda_core/cuda/core/_memory/_legacy.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -17,7 +17,7 @@
     driver,
 )
 
-__all__ = ["LegacyPinnedMemoryResource", "_SynchronousMemoryResource"]
+__all__ = ["LegacyPinnedMemoryResource"]
 
 
 class LegacyPinnedMemoryResource(MemoryResource):

cuda_core/tests/test_launcher.py

@@ -24,7 +24,7 @@
     ProgramOptions,
     launch,
 )
-from cuda.core._memory import _SynchronousMemoryResource
+from cuda.core._memory._legacy import _SynchronousMemoryResource
 from cuda.core._utils.cuda_utils import CUDAError