Merge remote-tracking branch 'upstream/main' into stubgen-0.2.19-update

Author: mdboom

AGENTS.md

@@ -14,16 +14,30 @@ guide for package-specific conventions and workflows.
 
 # Pull requests
 
-**Never push branches or commits to the canonical upstream repository. Treat
-it as read-only.** Branch creation and pushes for pull-request work must go to
-an approved fork associated with the contributor. The fork may be owned by the
-contributor's personal account or by an organization.
-
-Before pushing, run `git remote -v` and confirm that the intended push remote
-points to a fork of the pull-request base, not to the base repository itself.
-Compare complete `OWNER/REPOSITORY` names; do not rely on remote names such as
-`origin` or `upstream`, or on the owner alone. Do not use `git push upstream`
-or any command that writes to the upstream remote.
+Treat the canonical upstream repository as read-only by default. For normal
+pull-request work, push branches and commits to an approved fork associated
+with the contributor. The fork may be owned by the contributor's personal
+account or by an organization.
+
+Before any push, run `git remote -v` and verify the complete
+`OWNER/REPOSITORY` of the intended destination. For normal pull-request work,
+confirm that the destination is a fork of the pull-request base. Do not rely
+on remote names such as `origin` or `upstream`, or on the owner alone.
+
+An upstream push is allowed when the user explicitly requests it and provides
+a rationale for why the upstream repository is needed, such as testing
+`.github/workflows`, triggering CI from a designated upstream ref, or other
+infrastructure work.
+
+For an authorized upstream push, verify the exact source and destination refs
+against the user's request. If the repository and refspec are unambiguous,
+proceed; do not require the user to perform the push manually solely because
+the destination is upstream.
+
+Authorization is limited to the requested ref update. It does not authorize
+pushing to a default or protected branch, force-pushing, creating tags, or
+deleting refs unless the user separately and explicitly requests those
+operations.
 
 
 # General

cuda_bindings/tests/cython/build_tests.bat

@@ -4,7 +4,9 @@ REM SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIA
 REM SPDX-License-Identifier: Apache-2.0
 
 setlocal
-	set CL=%CL% /I"%CUDA_HOME%\include"
-	REM Use -j 1 to side-step any process-pool issues and ensure deterministic single-threaded builds
-	cythonize -3 -j 1 -i -Xfreethreading_compatible=True %~dp0test_*.pyx
-endlocal
+set CL=%CL% /I"%CUDA_HOME%\include"
+REM The Python driver provides Cython's .pxd include path and builds in this
+REM directory so Windows does not duplicate the checkout path in link outputs.
+python "%~dp0build_tests.py"
+set "BUILD_RESULT=%ERRORLEVEL%"
+endlocal & exit /b %BUILD_RESULT%

cuda_bindings/tests/cython/build_tests.py

@@ -34,7 +34,10 @@ def _bindings_source_root() -> Path:
 
 def main() -> None:
     script_dir = Path(__file__).resolve().parent
-    pyx_files = sorted(str(p) for p in script_dir.glob("test_*.pyx"))
+    # Avoid appending the absolute checkout path under build/temp: the
+    # concatenated path can exceed Windows' path limit. These files are siblings.
+    os.chdir(script_dir)
+    pyx_files = sorted(p.name for p in script_dir.glob("test_*.pyx"))
     if not pyx_files:
         raise SystemExit(f"no test_*.pyx files under {script_dir}")
 
@@ -46,13 +49,8 @@ def main() -> None:
         compiler_directives={"freethreading_compatible": True},
     )
 
-    # `build_ext --inplace` places the compiled .so relative to the current
-    # working directory, but pixi runs this task from the project root. pytest
-    # imports each extension by bare module name (see test_cython.py), which
-    # only resolves when the .so sits in tests/cython (the dir pytest puts on
-    # sys.path). chdir here so the .so lands next to its .pyx regardless of the
-    # invoking cwd.
-    os.chdir(script_dir)
+    # pytest imports each extension by bare module name (see test_cython.py),
+    # so build in-place next to its .pyx regardless of the invoking cwd.
     sys.argv = [sys.argv[0], "build_ext", "--inplace"]
     setup(name="cuda_bindings_cython_tests", ext_modules=ext_modules)
 

cuda_core/cuda/core/_cpp/resource_handles.cpp

@@ -111,6 +111,13 @@ decltype(&cuDevSmResourceSplit) p_cuDevSmResourceSplit = nullptr;
 void* p_cuDevSmResourceSplit = nullptr;
 #endif
 
+// cuMemcpyWithAttributesAsync (13.2+ — may be null on older drivers/bindings)
+#if CUDA_VERSION >= 13020
+decltype(&cuMemcpyWithAttributesAsync) p_cuMemcpyWithAttributesAsync = nullptr;
+#else
+void* p_cuMemcpyWithAttributesAsync = nullptr;
+#endif
+
 // NVRTC function pointers
 decltype(&nvrtcDestroyProgram) p_nvrtcDestroyProgram = nullptr;
 
@@ -2834,4 +2841,25 @@ bool has_sm_resource_split() noexcept {
     return p_cuDevSmResourceSplit != nullptr;
 }
 
+// ============================================================================
+// cuMemcpyWithAttributesAsync wrapper
+// ============================================================================
+
+CUresult memcpy_with_attributes_async(CUdeviceptr dst, CUdeviceptr src, size_t size,
+                                       void* attr, CUstream hStream) {
+#if CUDA_VERSION >= 13020
+    if (!p_cuMemcpyWithAttributesAsync) {
+        return CUDA_ERROR_NOT_SUPPORTED;
+    }
+    return p_cuMemcpyWithAttributesAsync(
+        dst, src, size, static_cast<CUmemcpyAttributes*>(attr), hStream);
+#else
+    return CUDA_ERROR_NOT_SUPPORTED;
+#endif
+}
+
+bool has_memcpy_with_attributes_async() noexcept {
+    return p_cuMemcpyWithAttributesAsync != nullptr;
+}
+
 }  // namespace cuda_core

cuda_core/cuda/core/_cpp/resource_handles.hpp

@@ -146,6 +146,15 @@ extern decltype(&cuDevSmResourceSplit) p_cuDevSmResourceSplit;
 extern void* p_cuDevSmResourceSplit;
 #endif
 
+// cuMemcpyWithAttributesAsync (13.2+ — may be null on older drivers/bindings)
+#if CUDA_VERSION >= 13020
+extern decltype(&cuMemcpyWithAttributesAsync) p_cuMemcpyWithAttributesAsync;
+#else
+// cuMemcpyWithAttributesAsync doesn't exist in CUDA < 13.2 headers, so use a
+// void* placeholder. The pointer is always null when built against older CUDA.
+extern void* p_cuMemcpyWithAttributesAsync;
+#endif
+
 // ============================================================================
 // NVRTC function pointers
 //
@@ -1110,4 +1119,21 @@ CUresult sm_resource_split(CUdevResource* result, unsigned int nbGroups,
 // Returns true if the cuDevSmResourceSplit function pointer is available.
 bool has_sm_resource_split() noexcept;
 
+// ============================================================================
+// cuMemcpyWithAttributesAsync wrapper (13.2+)
+//
+// Calls through p_cuMemcpyWithAttributesAsync if available, otherwise returns
+// CUDA_ERROR_NOT_SUPPORTED. This avoids a direct Cython cimport of the
+// cydriver cdef function, which would fail at module init on cuda-bindings
+// < 13.2 (see https://github.com/NVIDIA/cuda-python/issues/2063).
+// ============================================================================
+
+// attr is void* so the Cython declaration doesn't reference CUmemcpyAttributes
+// (absent from cuda-bindings built against CUDA < 12.8). The C++ side casts it.
+CUresult memcpy_with_attributes_async(CUdeviceptr dst, CUdeviceptr src, size_t size,
+                                       void* attr, CUstream hStream);
+
+// Returns true if the cuMemcpyWithAttributesAsync function pointer is available.
+bool has_memcpy_with_attributes_async() noexcept;
+
 }  // namespace cuda_core

cuda_core/cuda/core/_memory/_buffer.pyi

@@ -2,6 +2,7 @@
 
 from typing import TypedDict
 
+from cuda.core._memory._copy_enums import CopyOptions
 from cuda.core._memory._device_memory_resource import DeviceMemoryResource
 from cuda.core._memory._ipc import IPCBufferDescriptor
 from cuda.core._memory._pinned_memory_resource import PinnedMemoryResource
@@ -149,7 +150,7 @@ class Buffer:
         """
     def __enter__(self): ...
     def __exit__(self, exc_type, exc_val, exc_tb): ...
-    def copy_to(self, dst: Buffer | None=None, *, stream: Stream | GraphBuilder) -> Buffer:
+    def copy_to(self, dst: Buffer | None=None, *, stream: Stream | GraphBuilder, options: CopyOptions | None=None) -> Buffer:
         """Copy from this buffer to the dst buffer asynchronously on the given stream.
 
         Copies the data from this buffer to the provided dst buffer.
@@ -164,9 +165,31 @@ class Buffer:
         stream : :obj:`~_stream.Stream` | :obj:`~graph.GraphBuilder`
             Keyword argument specifying the stream for the
             asynchronous copy
+        options : :class:`~utils.CopyOptions`, optional
+            Transfer hints (source access order, location hints, overlap mode).
+            Honored when cuda.bindings and the driver are both CUDA 13.2 or
+            newer. Not accepted with ``LEGACY_DEFAULT_STREAM``; use
+            ``PER_THREAD_DEFAULT_STREAM`` instead. Not accepted with a
+            capturing stream either, since a graph cannot represent these
+            attributes; use :meth:`graph.GraphNode.memcpy` for a plain,
+            non-attributed copy node, or pass ``options=None``. On an older
+            cuda.bindings/driver, ``src_access_order`` values of ``STREAM``
+            and ``ANY`` are silently ignored; ``DURING_API_CALL`` raises
+            instead of silently downgrading its guarantee.
+
+        Raises
+        ------
+        TypeError
+            If ``options`` is not a :class:`~utils.CopyOptions` instance, or
+            if ``options`` is given together with ``LEGACY_DEFAULT_STREAM``
+            or a stream currently in graph capture mode.
+        RuntimeError
+            If ``options.src_access_order`` is ``DURING_API_CALL`` and
+            cuda.bindings or the driver is older than CUDA 13.2: falling
+            back to a plain copy cannot honor that guarantee.
 
         """
-    def copy_from(self, src: Buffer, *, stream: Stream | GraphBuilder) -> None:
+    def copy_from(self, src: Buffer, *, stream: Stream | GraphBuilder, options: CopyOptions | None=None) -> None:
         """Copy from the src buffer to this buffer asynchronously on the given stream.
 
         Parameters
@@ -176,7 +199,28 @@ class Buffer:
         stream : :obj:`~_stream.Stream` | :obj:`~graph.GraphBuilder`
             Keyword argument specifying the stream for the
             asynchronous copy
+        options : :class:`~utils.CopyOptions`, optional
+            Transfer hints (source access order, location hints, overlap mode).
+            Honored when cuda.bindings and the driver are both CUDA 13.2 or
+            newer. Not accepted with ``LEGACY_DEFAULT_STREAM``; use
+            ``PER_THREAD_DEFAULT_STREAM`` instead. Not accepted with a
+            capturing stream either, since a graph cannot represent these
+            attributes; use :meth:`graph.GraphNode.memcpy` for a plain,
+            non-attributed copy node, or pass ``options=None``. On an older
+            cuda.bindings/driver, ``src_access_order`` values of ``STREAM``
+            and ``ANY`` are silently ignored; ``DURING_API_CALL`` raises
+            instead of silently downgrading its guarantee.
 
+        Raises
+        ------
+        TypeError
+            If ``options`` is not a :class:`~utils.CopyOptions` instance, or
+            if ``options`` is given together with ``LEGACY_DEFAULT_STREAM``
+            or a stream currently in graph capture mode.
+        RuntimeError
+            If ``options.src_access_order`` is ``DURING_API_CALL`` and
+            cuda.bindings or the driver is older than CUDA 13.2: falling
+            back to a plain copy cannot honor that guarantee.
         """
     def fill(self, value: int | BufferProtocol, *, stream: Stream | GraphBuilder) -> None:
         """Fill this buffer with a repeating byte pattern.