Merge branch 'main' into fix/program-options-name-none

Author: mdboom

.pre-commit-config.yaml

@@ -58,6 +58,12 @@ repos:
         files: '^(ci/versions\.yml|cuda_bindings/pixi\.toml|cuda_core/pixi\.toml)$'
         pass_filenames: false
 
+      - id: check-mempool-hygiene
+        name: Check tests do not create uncapped memory pools
+        entry: python ./ci/tools/check_mempool_hygiene.py
+        language: python
+        files: '^cuda_core/tests/.*\.py$'
+
       - id: no-markdown-in-docs-source
         name: Prevent markdown files in docs/source directories
         entry: bash -c

ci/tools/check_mempool_hygiene.py

@@ -0,0 +1,113 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Check that tests do not create uncapped CUDA memory pools.
+
+A pool created without ``max_size`` reserves an address-space window sized from
+installed device memory rather than from what the test allocates, and the whole
+cuda_core suite shares one process. Enough of those reservations exhaust the
+address space, after which the rest of the session fails with
+CUDA_ERROR_OUT_OF_MEMORY on a device with free physical memory.
+
+See cuda_core/tests/AGENTS.md for the rule this enforces.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_TREE = ROOT / "cuda_core" / "tests"
+
+# Managed pools cannot be right-sized: cuMemPoolCreate requires maxSize == 0 for
+# managed pools, so ManagedMemoryResourceOptions has no max_size to set.
+CAPPABLE_OPTIONS = frozenset({"DeviceMemoryResourceOptions", "PinnedMemoryResourceOptions"})
+CAPPABLE_RESOURCES = frozenset({"DeviceMemoryResource", "PinnedMemoryResource"})
+
+OPT_OUT_MARKER = "uncapped-pool-ok"
+
+
+def _callee_name(node: ast.Call) -> str:
+    func = node.func
+    if isinstance(func, ast.Attribute):
+        return func.attr
+    if isinstance(func, ast.Name):
+        return func.id
+    return ""
+
+
+def _is_capped(node: ast.Call) -> bool:
+    # ``**kwargs`` (arg is None) may carry max_size; do not guess.
+    return any(kw.arg is None or kw.arg == "max_size" for kw in node.keywords)
+
+
+def _dict_is_capped(node: ast.Dict) -> bool:
+    for key in node.keys:
+        if key is None:  # ``**other`` inside the literal
+            return True
+        if isinstance(key, ast.Constant) and key.value == "max_size":
+            return True
+    return False
+
+
+def _opted_out(lines: list[str], node: ast.AST) -> bool:
+    """True if the call, or the line above it, carries the opt-out marker."""
+    start = max(node.lineno - 2, 0)  # -1 for 0-based, -1 more for a preceding comment
+    end = getattr(node, "end_lineno", node.lineno)
+    return any(OPT_OUT_MARKER in line for line in lines[start:end])
+
+
+def violations_in(path: Path) -> list[str]:
+    """Return one message per uncapped pool construction in ``path``."""
+    source = path.read_text(encoding="utf-8")
+    lines = source.splitlines()
+    found = []
+    for node in ast.walk(ast.parse(source, filename=str(path))):
+        if not isinstance(node, ast.Call):
+            continue
+        name = _callee_name(node)
+        if name in CAPPABLE_OPTIONS:
+            uncapped = not _is_capped(node)
+        elif name in CAPPABLE_RESOURCES:
+            # The options may also be given as a dict literal.
+            dicts = [arg for arg in [*node.args, *(kw.value for kw in node.keywords)] if isinstance(arg, ast.Dict)]
+            uncapped = any(not _dict_is_capped(d) for d in dicts)
+        else:
+            continue
+        if uncapped and not _opted_out(lines, node):
+            found.append(f"{path.as_posix()}:{node.lineno}: {name} without max_size")
+    return found
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        type=Path,
+        help=f"Files to check. Defaults to every .py under {DEFAULT_TREE.relative_to(ROOT).as_posix()}.",
+    )
+    args = parser.parse_args(argv)
+
+    paths = args.paths or sorted(DEFAULT_TREE.rglob("*.py"))
+    violations = sorted(v for path in paths if path.suffix == ".py" for v in violations_in(path))
+    if not violations:
+        return 0
+
+    print("error: memory pools created by tests must set max_size:", file=sys.stderr)
+    for violation in violations:
+        print(f"  - {violation}", file=sys.stderr)
+    print(
+        f"Use the suite-wide POOL_SIZE from cuda_core/tests/helpers/constants.py, or annotate a\n"
+        f"deliberate exception with a '# {OPT_OUT_MARKER}: <reason>' comment.\n"
+        f"See cuda_core/tests/AGENTS.md.",
+        file=sys.stderr,
+    )
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ci/tools/merge_cuda_core_wheels.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-# 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
 
@@ -27,10 +27,9 @@
 import tempfile
 import zipfile
 from pathlib import Path
-from typing import List
 
 
-def run_command(cmd: List[str], cwd: Path | None = None, env: dict = os.environ) -> subprocess.CompletedProcess:
+def run_command(cmd: list[str], cwd: Path | None = None, env: dict = os.environ) -> subprocess.CompletedProcess:
     """Run a command with error handling."""
     print(f"Running: {' '.join(cmd)}")
     if cwd:
@@ -78,7 +77,7 @@ def print_wheel_directory_structure(wheel_path: Path, filter_prefix: str = "cuda
         print(f"Warning: Could not list wheel contents: {e}", file=sys.stderr)
 
 
-def merge_wheels(wheels: List[Path], output_dir: Path, show_wheel_contents: bool = True) -> Path:
+def merge_wheels(wheels: list[Path], output_dir: Path, show_wheel_contents: bool = True) -> Path:
     """Merge multiple wheels into a single wheel with version-specific binaries."""
     print("\n=== Merging wheels ===", file=sys.stderr)
     print(f"Input wheels: {[w.name for w in wheels]}", file=sys.stderr)

ci/tools/tests/test_check_mempool_hygiene.py

@@ -0,0 +1,96 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from check_mempool_hygiene import DEFAULT_TREE, main, violations_in
+
+
+def write(tmp_path, source):
+    path = tmp_path / "test_sample.py"
+    path.write_text(source, encoding="utf-8")
+    return path
+
+
+UNCAPPED = [
+    pytest.param("DeviceMemoryResource(dev, DeviceMemoryResourceOptions(ipc_enabled=True))", id="options-kwarg"),
+    pytest.param("PinnedMemoryResource(PinnedMemoryResourceOptions())", id="options-empty"),
+    pytest.param('DeviceMemoryResource(dev, {"ipc_enabled": True})', id="options-dict"),
+]
+
+CAPPED = [
+    pytest.param("DeviceMemoryResource(dev, DeviceMemoryResourceOptions(max_size=POOL_SIZE))", id="capped-kwarg"),
+    pytest.param('DeviceMemoryResource(dev, {"max_size": POOL_SIZE})', id="capped-dict"),
+    pytest.param("DeviceMemoryResource(dev, DeviceMemoryResourceOptions(**opts))", id="opaque-kwargs"),
+    # No options at all wraps the device's default pool and reserves nothing, so
+    # capping it would convert a free wrapper into a new pool.
+    pytest.param("DeviceMemoryResource(dev)", id="default-pool-wrapper"),
+    # cuMemPoolCreate requires maxSize == 0 for managed pools, so these have no
+    # max_size to set.
+    pytest.param("ManagedMemoryResource(ManagedMemoryResourceOptions(preferred_location=0))", id="managed-exempt"),
+]
+
+
+@pytest.mark.agent_authored(model="claude-opus-5")
+@pytest.mark.parametrize("source", UNCAPPED)
+def test_uncapped_pool_is_reported(tmp_path, source):
+    assert violations_in(write(tmp_path, source))
+
+
+@pytest.mark.agent_authored(model="claude-opus-5")
+@pytest.mark.parametrize("source", CAPPED)
+def test_acceptable_construction_is_not_reported(tmp_path, source):
+    assert violations_in(write(tmp_path, source)) == []
+
+
+@pytest.mark.agent_authored(model="claude-opus-5")
+@pytest.mark.parametrize("comment_line", [0, 1], ids=["marker-above", "marker-inline"])
+def test_marker_opts_a_call_out(tmp_path, comment_line):
+    # The escape hatch exists mainly for pytest.raises cases, where validation
+    # rejects the arguments before any pool is created.
+    call = "PinnedMemoryResource(PinnedMemoryResourceOptions())"
+    marker = "# uncapped-pool-ok: raises before the pool is created"
+    source = f"{marker}\n{call}" if comment_line == 0 else f"{call}  {marker}"
+
+    assert violations_in(write(tmp_path, source)) == []
+
+
+@pytest.mark.agent_authored(model="claude-opus-5")
+def test_reported_message_names_file_line_and_symbol(tmp_path):
+    path = write(tmp_path, "x = 1\nDeviceMemoryResource(dev, DeviceMemoryResourceOptions())\n")
+
+    (violation,) = violations_in(path)
+
+    assert violation.startswith(path.as_posix())
+    assert ":2:" in violation
+    assert "DeviceMemoryResourceOptions without max_size" in violation
+
+
+@pytest.mark.agent_authored(model="claude-opus-5")
+def test_main_reports_failure_for_the_files_it_is_given(tmp_path, capsys):
+    path = write(tmp_path, "DeviceMemoryResource(dev, DeviceMemoryResourceOptions())")
+
+    assert main([str(path)]) == 1
+    assert "must set max_size" in capsys.readouterr().err
+
+
+@pytest.mark.agent_authored(model="claude-opus-5")
+def test_main_ignores_non_python_files(tmp_path):
+    unrelated = tmp_path / "notes.txt"
+    unrelated.write_text("DeviceMemoryResourceOptions()", encoding="utf-8")
+
+    assert main([str(unrelated)]) == 0
+
+
+@pytest.mark.agent_authored(model="claude-opus-5")
+def test_the_live_test_suite_is_clean():
+    # Without a default the hook would only ever see changed files, so a
+    # violation could ride in on a rename or a merge.
+    assert DEFAULT_TREE.is_dir()
+    assert main([]) == 0

cuda_bindings/build_hooks.py

@@ -16,6 +16,7 @@
 import sys
 import sysconfig
 import tempfile
+from pathlib import Path
 from warnings import warn
 
 from setuptools import build_meta as _build_meta
@@ -50,9 +51,9 @@ def _import_get_cuda_path_or_home():
             cuda = None
 
         for p in sys.path:
-            sp_cuda = os.path.join(p, "cuda")
-            if os.path.isdir(os.path.join(sp_cuda, "pathfinder")):
-                cuda.__path__ = list(cuda.__path__) + [sp_cuda]
+            sp_cuda = Path(p) / "cuda"
+            if (sp_cuda / "pathfinder").is_dir():
+                cuda.__path__ = list(cuda.__path__) + [str(sp_cuda)]
                 break
         else:
             raise ModuleNotFoundError(
@@ -61,6 +62,11 @@ def _import_get_cuda_path_or_home():
             )
         import cuda.pathfinder
 
+    pathfinder_dir = Path(cuda.pathfinder.__file__).parent
+    print(
+        f"Using cuda-pathfinder {cuda.pathfinder.__version__} from {pathfinder_dir}",
+        file=sys.stderr,
+    )
     return cuda.pathfinder.get_cuda_path_or_home
 
 

cuda_bindings/tests/nvml/test_init.py

@@ -7,6 +7,7 @@
 import pytest
 
 from cuda.bindings import nvml
+from cuda_python_test_helpers import driver_version_less_than
 
 
 def assert_nvml_is_initialized():
@@ -43,6 +44,7 @@ def get_architecture_name(arch):
 
 @pytest.mark.skipif(sys.platform == "win32", reason="Test not supported on Windows")
 @pytest.mark.thread_unsafe(reason="nvml init affects other threads")
+@pytest.mark.skipif(not driver_version_less_than(13040), reason="Init behavior changed in CUDA 13.4")
 def test_init_ref_count():
     """
     Verifies that we can call NVML shutdown and init(2) multiple times, and that ref counting works