Merge remote-tracking branch 'upstream/main' into fix/adjacency-discard-annotation-typing

# Conflicts:
#	cuda_core/docs/source/release/1.3.0-notes.rst

Author: rluo8

.github/workflows/build-wheel.yml

@@ -223,19 +223,14 @@ jobs:
 
       - name: Build cuda.bindings wheel
         if: ${{ env.BUILD_BINDINGS == 'true' }}
-        uses: pypa/cibuildwheel@1828c10ab37f080699c7b81cea34097c684a7074  # v4.2.0
+        uses: pypa/cibuildwheel@e090b81e30c4d855ea63bf4b6e59204c09a101ae  # v4.2.1
         with:
           package-dir: ./cuda_bindings/
           output-dir: ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}
         env:
           CIBW_BUILD: ${{ env.CIBW_BUILD }}
           CIBW_BEFORE_BUILD_LINUX: 'python -m pip install --upgrade "pip>=25.3"'
           CIBW_BEFORE_BUILD_WINDOWS: 'python -m pip install --upgrade "pip>=25.3" delvewheel'
-          # TODO: remove cpython-prerelease once 3.15 is officially supported
-          # Allow CPython pre-release builds (currently 3.15 / 3.15t). This is a
-          # no-op for stable Python versions because CIBW_BUILD still filters
-          # the target version.
-          CIBW_ENABLE: cpython-prerelease
           # CIBW mounts the host filesystem under /host
           CIBW_ENVIRONMENT_LINUX: >
             CUDA_PATH=/host/${{ env.CUDA_PATH }}
@@ -250,8 +245,6 @@ jobs:
             ACTIONS_RESULTS_URL=${{ env.ACTIONS_RESULTS_URL }}
             ACTIONS_CACHE_URL=${{ env.ACTIONS_CACHE_URL }}
             ACTIONS_CACHE_SERVICE_V2=${{ env.ACTIONS_CACHE_SERVICE_V2 }}
-            SCCACHE_DIR=/host/${{ env.SCCACHE_DIR }}
-            SCCACHE_CACHE_SIZE=${{ env.SCCACHE_CACHE_SIZE }}
           CIBW_ENVIRONMENT_WINDOWS: >
             CUDA_PATH="$(cygpath -w ${{ env.CUDA_PATH }})"
             CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }}
@@ -330,19 +323,14 @@ jobs:
 
       - name: Build cuda.core wheel
         if: ${{ env.BUILD_CORE == 'true' }}
-        uses: pypa/cibuildwheel@1828c10ab37f080699c7b81cea34097c684a7074  # v4.2.0
+        uses: pypa/cibuildwheel@e090b81e30c4d855ea63bf4b6e59204c09a101ae  # v4.2.1
         with:
           package-dir: ./cuda_core/
           output-dir: ${{ env.CUDA_CORE_ARTIFACTS_DIR }}
         env:
           CIBW_BUILD: ${{ env.CIBW_BUILD }}
           CIBW_BEFORE_BUILD_LINUX: 'python -m pip install --upgrade "pip>=25.3"'
           CIBW_BEFORE_BUILD_WINDOWS: 'python -m pip install --upgrade "pip>=25.3" delvewheel'
-          # TODO: remove cpython-prerelease once 3.15 is officially supported
-          # Allow CPython pre-release builds (currently 3.15 / 3.15t). This is a
-          # no-op for stable Python versions because CIBW_BUILD still filters
-          # the target version.
-          CIBW_ENABLE: cpython-prerelease
           # CIBW mounts the host filesystem under /host
           CIBW_ENVIRONMENT_LINUX: >
             CUDA_PATH=/host/${{ env.CUDA_PATH }}
@@ -358,8 +346,6 @@ jobs:
             ACTIONS_RESULTS_URL=${{ env.ACTIONS_RESULTS_URL }}
             ACTIONS_CACHE_URL=${{ env.ACTIONS_CACHE_URL }}
             ACTIONS_CACHE_SERVICE_V2=${{ env.ACTIONS_CACHE_SERVICE_V2 }}
-            SCCACHE_DIR=/host/${{ env.SCCACHE_DIR }}
-            SCCACHE_CACHE_SIZE=${{ env.SCCACHE_CACHE_SIZE }}
           CIBW_ENVIRONMENT_WINDOWS: >
             CUDA_PATH="$(cygpath -w ${{ env.CUDA_PATH }})"
             CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }}
@@ -624,19 +610,14 @@ jobs:
 
       - name: Build cuda.core wheel
         if: ${{ !inputs.single-cuda-major && env.BUILD_CORE == 'true' }}
-        uses: pypa/cibuildwheel@1828c10ab37f080699c7b81cea34097c684a7074  # v4.2.0
+        uses: pypa/cibuildwheel@e090b81e30c4d855ea63bf4b6e59204c09a101ae  # v4.2.1
         with:
           package-dir: ./cuda_core/
           output-dir: ${{ env.CUDA_CORE_ARTIFACTS_DIR }}
         env:
           CIBW_BUILD: ${{ env.CIBW_BUILD }}
           CIBW_BEFORE_BUILD_LINUX: 'python -m pip install --upgrade "pip>=25.3"'
           CIBW_BEFORE_BUILD_WINDOWS: 'python -m pip install --upgrade "pip>=25.3" delvewheel'
-          # TODO: remove cpython-prerelease once 3.15 is officially supported
-          # Allow CPython pre-release builds (currently 3.15 / 3.15t). This is a
-          # no-op for stable Python versions because CIBW_BUILD still filters
-          # the target version.
-          CIBW_ENABLE: cpython-prerelease
           # CIBW mounts the host filesystem under /host
           CIBW_ENVIRONMENT_LINUX: >
             CUDA_PATH=/host/${{ env.CUDA_PATH }}
@@ -652,8 +633,6 @@ jobs:
             ACTIONS_RESULTS_URL=${{ env.ACTIONS_RESULTS_URL }}
             ACTIONS_CACHE_URL=${{ env.ACTIONS_CACHE_URL }}
             ACTIONS_CACHE_SERVICE_V2=${{ env.ACTIONS_CACHE_SERVICE_V2 }}
-            SCCACHE_DIR=/host/${{ env.SCCACHE_DIR }}
-            SCCACHE_CACHE_SIZE=${{ env.SCCACHE_CACHE_SIZE }}
           CIBW_ENVIRONMENT_WINDOWS: >
             CUDA_PATH="$(cygpath -w ${{ env.CUDA_PATH }})"
             CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }}

ci/tools/env-vars

@@ -56,9 +56,6 @@ if [[ "${1}" == "build" ]]; then
   echo "BUILD_CUDA_MAJOR=${BUILD_CUDA_MAJOR}" >> $GITHUB_ENV
   echo "BUILD_PREV_CUDA_MAJOR=$((${BUILD_CUDA_MAJOR} - 1))" >> $GITHUB_ENV
   CUDA_BINDINGS_ARTIFACT_BASENAME="cuda-bindings-python${PYTHON_VERSION_FORMATTED}-cuda${CUDA_VER}-${HOST_PLATFORM}"
-  # Enforce an explicit cache dir so that we can reuse this path later
-  echo "SCCACHE_DIR=${HOME}/.cache/sccache" >> $GITHUB_ENV
-  echo "SCCACHE_CACHE_SIZE=1G" >> $GITHUB_ENV
 elif [[ "${1}" == "test" ]]; then
   BUILD_CUDA_MAJOR="$(cut -d '.' -f 1 <<< ${BUILD_CUDA_VER})"
   TEST_CUDA_MAJOR="$(cut -d '.' -f 1 <<< ${CUDA_VER})"

cuda_bindings/build_hooks.py

@@ -185,7 +185,7 @@ def _build_cuda_bindings(debug=False):
             extra_compile_args += ["-g", "-O0"]
             extra_compile_args += ["-D _GLIBCXX_ASSERTIONS"]
         else:
-            extra_compile_args += ["-O3"]
+            extra_compile_args += ["-g0", "-O3"]
             extra_link_args += ["-Wl,--strip-all"]
     if compile_for_coverage:
         # CYTHON_TRACE_NOGIL indicates to trace nogil functions.  It is not

cuda_bindings/tests/nvml/test_device.py

@@ -198,26 +198,31 @@ def test_device_get_samples_zero_result_returns_tuple(all_devices, subtests):
     even when there are zero samples to report, instead of a bare Sample instance.
     """
     for device in all_devices:
-        with subtests.test(device_index=nvml.device_get_index(device)):
-            with unsupported_before(device, None):
-                # _FUTURE_TIMESTAMP is newer than any sample can ever be, so the
-                # zero-sample result is deterministic and cannot race with a
-                # newly arriving sample (unlike querying "now" and re-querying).
+        with subtests.test(device_index=nvml.device_get_index(device)), unsupported_before(device, None):
+            last_seen_timestamp = 0
+            for _ in range(3):
                 try:
                     result = nvml.device_get_samples(
-                        device, nvml.SamplingType.GPU_UTILIZATION_SAMPLES, _FUTURE_TIMESTAMP
+                        device, nvml.SamplingType.GPU_UTILIZATION_SAMPLES, last_seen_timestamp
                     )
                 except nvml.NotFoundError:
                     # Some drivers report NotFoundError instead of a zero-sample
-                    # SUCCESS when there is nothing newer than the timestamp;
-                    # that is also an acceptable (non-crashing) outcome.
-                    continue
+                    # SUCCESS when there is nothing newer than the timestamp.
+                    break
 
-            assert isinstance(result, tuple)
-            assert len(result) == 2
-            sample_val_type, samples = result
-            assert isinstance(sample_val_type, int)
-            assert len(samples) == 0
+                assert isinstance(result, tuple)
+                assert len(result) == 2
+                sample_val_type, samples = result
+                assert isinstance(sample_val_type, int)
+                if len(samples) == 0:
+                    break
+
+                # NVML documents zero or a timestamp from a previous query.
+                # Advance to the newest returned sample and try to observe the
+                # zero-result path before another sample arrives.
+                last_seen_timestamp = max(sample.time_stamp for sample in samples)
+            else:
+                pytest.skip("NVML continued producing samples before an empty result could be observed")
 
 
 def _check_vgpu_type_id_list(type_ids):

cuda_core/build_hooks.py

@@ -281,7 +281,7 @@ def module_names():
             extra_compile_args += ["-g", "-O0"]
             extra_compile_args += ["-D _GLIBCXX_ASSERTIONS"]
         else:
-            extra_compile_args += ["-O2"]
+            extra_compile_args += ["-g0", "-O2"]
             extra_link_args += ["-Wl,--strip-all"]
     if COMPILE_FOR_COVERAGE:
         # CYTHON_TRACE_NOGIL indicates to trace nogil functions.  It is not

cuda_core/cuda/core/_cpp/rt/memory.cpp

@@ -14,7 +14,6 @@
 #include <mutex>
 #include <stdexcept>
 #include <utility>
-#include <vector>
 #ifndef _WIN32
 #include <unistd.h>
 #endif
@@ -35,32 +34,42 @@ struct MemoryPoolBox {
 
 // Helper to clear peer access before destroying a memory pool.
 // Works around nvbug 5698116: recycled pool handles inherit peer access state.
+// The driver validates a request as a whole and rejects it if any entry cannot
+// be applied: the pool's own device, a device without memory-map support, or
+// devices of more than one kind in one request. Each device is therefore
+// revoked with its own request, and the owning device (-1 if the pool has
+// none) is not requested at all.
 // Must be noexcept since it's called from a shared_ptr deleter.
-static void clear_mempool_peer_access(CUmemoryPool pool) noexcept {
+static void clear_mempool_peer_access(CUmemoryPool pool, int owner_device) noexcept {
     try {
         int device_count = 0;
         if (p_cuDeviceGetCount(&device_count) != CUDA_SUCCESS || device_count <= 0) {
             return;
         }
 
-        std::vector<CUmemAccessDesc> clear_access(device_count);
+        CUmemAccessDesc revoke{};
+        revoke.location.type = CU_MEM_LOCATION_TYPE_DEVICE;
+        revoke.flags = CU_MEM_ACCESS_FLAGS_PROT_NONE;
         for (int i = 0; i < device_count; ++i) {
-            clear_access[i].location.type = CU_MEM_LOCATION_TYPE_DEVICE;
-            clear_access[i].location.id = i;
-            clear_access[i].flags = CU_MEM_ACCESS_FLAGS_PROT_NONE;
+            if (i == owner_device) {
+                continue;
+            }
+            revoke.location.id = i;
+            p_cuMemPoolSetAccess(pool, &revoke, 1);  // Best effort
         }
-        p_cuMemPoolSetAccess(pool, clear_access.data(), device_count);  // Best effort
     } catch (...) {
         // Swallow exceptions - this is best-effort cleanup in destructor context
     }
 }
 
-static MemoryPoolHandle wrap_mempool_owned(CUmemoryPool pool) {
+// owner_device is the ordinal of a device-located pool, or -1 when there is no
+// device to skip (host pools) or the location is unknown (imported pools).
+static MemoryPoolHandle wrap_mempool_owned(CUmemoryPool pool, int owner_device) {
     auto box = std::shared_ptr<const MemoryPoolBox>(
         new MemoryPoolBox{pool},
-        [](const MemoryPoolBox* b) {
+        [owner_device](const MemoryPoolBox* b) {
             GILReleaseGuard gil;
-            clear_mempool_peer_access(b->resource);
+            clear_mempool_peer_access(b->resource, owner_device);
             pw_cuMemPoolDestroy(b->resource);
             delete b;
         }
@@ -74,7 +83,8 @@ MemoryPoolHandle create_mempool_handle(const CUmemPoolProps& props) {
     if (CUDA_SUCCESS != (err = p_cuMemPoolCreate(&pool, &props))) {
         return {};
     }
-    return wrap_mempool_owned(pool);
+    int owner_device = props.location.type == CU_MEM_LOCATION_TYPE_DEVICE ? props.location.id : -1;
+    return wrap_mempool_owned(pool, owner_device);
 }
 
 MemoryPoolHandle create_mempool_handle_ref(CUmemoryPool pool) {
@@ -98,7 +108,7 @@ MemoryPoolHandle create_mempool_handle_ipc(int fd, CUmemAllocationHandleType han
     if (CUDA_SUCCESS != (err = p_cuMemPoolImportFromShareableHandle(&pool, handle_ptr, handle_type, 0))) {
         return {};
     }
-    return wrap_mempool_owned(pool);
+    return wrap_mempool_owned(pool, -1);
 }
 
 // ============================================================================

cuda_core/cuda/core/_memory/_virtual_memory_resource.py

@@ -329,19 +329,18 @@ def _grow_allocation_fast_path(
         """
         with Transaction() as trans:
             # Create new physical memory for the additional size
-            trans.append(
+            trans.on_failure(
                 lambda np=new_ptr, s=aligned_additional_size: raise_if_driver_error(driver.cuMemAddressFree(np, s)[0])
             )
             res, new_handle = driver.cuMemCreate(aligned_additional_size, prop, 0)
             raise_if_driver_error(res)
-            # Register undo for creation
-            trans.append(lambda h=new_handle: raise_if_driver_error(driver.cuMemRelease(h)[0]))
+            trans.on_exit(lambda h=new_handle: raise_if_driver_error(driver.cuMemRelease(h)[0]))
 
             # Map the new physical memory to the extended VA range
             (res,) = driver.cuMemMap(new_ptr, aligned_additional_size, 0, new_handle, 0)
             raise_if_driver_error(res)
             # Register undo for mapping
-            trans.append(
+            trans.on_failure(
                 lambda np=new_ptr, s=aligned_additional_size: raise_if_driver_error(driver.cuMemUnmap(np, s)[0])
             )
 
@@ -393,15 +392,14 @@ def _grow_allocation_slow_path(
             res, new_ptr = driver.cuMemAddressReserve(total_aligned_size, addr_align, 0, 0)
             raise_if_driver_error(res)
             # Register undo for VA reservation
-            trans.append(
+            trans.on_failure(
                 lambda np=new_ptr, s=total_aligned_size: raise_if_driver_error(driver.cuMemAddressFree(np, s)[0])
             )
 
             # Get the old allocation handle for remapping
             result, old_handle = driver.cuMemRetainAllocationHandle(buf.handle)
             raise_if_driver_error(result)
-            # Register undo for old_handle
-            trans.append(lambda h=old_handle: raise_if_driver_error(driver.cuMemRelease(h)[0]))
+            trans.on_exit(lambda h=old_handle: raise_if_driver_error(driver.cuMemRelease(h)[0]))
 
             # Unmap the old VA range (aligned previous size)
             aligned_prev_size = total_aligned_size - aligned_additional_size
@@ -417,28 +415,26 @@ def _remap_old() -> None:
                     # TODO: consider logging this exception
                     pass
 
-            trans.append(_remap_old)
+            trans.on_failure(_remap_old)
 
             # Remap the old physical memory to the new VA range (aligned previous size)
             (res,) = driver.cuMemMap(int(new_ptr), aligned_prev_size, 0, old_handle, 0)
             raise_if_driver_error(res)
 
             # Register undo for mapping
-            trans.append(lambda np=new_ptr, s=aligned_prev_size: raise_if_driver_error(driver.cuMemUnmap(np, s)[0]))
+            trans.on_failure(lambda np=new_ptr, s=aligned_prev_size: raise_if_driver_error(driver.cuMemUnmap(np, s)[0]))
 
             # Create new physical memory for the additional size
             res, new_handle = driver.cuMemCreate(aligned_additional_size, prop, 0)
             raise_if_driver_error(res)
-
-            # Register undo for new physical memory
-            trans.append(lambda h=new_handle: raise_if_driver_error(driver.cuMemRelease(h)[0]))
+            trans.on_exit(lambda h=new_handle: raise_if_driver_error(driver.cuMemRelease(h)[0]))
 
             # Map the new physical memory to the extended portion (aligned offset)
             (res,) = driver.cuMemMap(int(new_ptr) + aligned_prev_size, aligned_additional_size, 0, new_handle, 0)
             raise_if_driver_error(res)
 
             # Register undo for mapping
-            trans.append(
+            trans.on_failure(
                 lambda base=int(new_ptr), offs=aligned_prev_size, s=aligned_additional_size: raise_if_driver_error(
                     driver.cuMemUnmap(base + offs, s)[0]
                 )
@@ -553,20 +549,20 @@ def allocate(self, size: int, *, stream: Stream | GraphBuilder | None = None) ->
             # ---- Create physical memory ----
             res, handle = driver.cuMemCreate(aligned_size, prop, 0)
             raise_if_driver_error(res)
-            # Register undo for physical memory
-            trans.append(lambda h=handle: raise_if_driver_error(driver.cuMemRelease(h)[0]))
+            # Drop the creation reference on either outcome; a successful mapping keeps the allocation alive.
+            trans.on_exit(lambda h=handle: raise_if_driver_error(driver.cuMemRelease(h)[0]))
 
             # ---- Reserve VA space ----
             # Potentially, use a separate size for the VA reservation from the physical allocation size
             res, ptr = driver.cuMemAddressReserve(aligned_size, addr_align, config.addr_hint, 0)
             raise_if_driver_error(res)
             # Register undo for VA reservation
-            trans.append(lambda p=ptr, s=aligned_size: raise_if_driver_error(driver.cuMemAddressFree(p, s)[0]))
+            trans.on_failure(lambda p=ptr, s=aligned_size: raise_if_driver_error(driver.cuMemAddressFree(p, s)[0]))
 
             # ---- Map physical memory into VA ----
             (res,) = driver.cuMemMap(ptr, aligned_size, 0, handle, 0)
-            trans.append(lambda p=ptr, s=aligned_size: raise_if_driver_error(driver.cuMemUnmap(p, s)[0]))
             raise_if_driver_error(res)
+            trans.on_failure(lambda p=ptr, s=aligned_size: raise_if_driver_error(driver.cuMemUnmap(p, s)[0]))
 
             # ---- Set access for owner + peers ----
             descs = self._build_access_descriptors(prop)
@@ -600,14 +596,11 @@ def deallocate(self, ptr: DevicePointerType, size: int, *, stream: Stream | Grap
             from cuda.core._stream import Stream_accept
 
             Stream_accept(stream)
-        result, handle = driver.cuMemRetainAllocationHandle(ptr)
-        raise_if_driver_error(result)
+        # The mapping owns the allocation; unmapping frees its backing memory when no external references remain.
         (result,) = driver.cuMemUnmap(ptr, size)
         raise_if_driver_error(result)
         (result,) = driver.cuMemAddressFree(ptr, size)
         raise_if_driver_error(result)
-        (result,) = driver.cuMemRelease(handle)
-        raise_if_driver_error(result)
 
     @property
     def is_device_accessible(self) -> bool:

cuda_core/cuda/core/_program.pxd

@@ -21,4 +21,5 @@ cdef class Program:
         str _code_type          # Normalised code_type ("c++", "ptx", "nvvm")
         str _pch_status         # PCH creation outcome after compile
         bytes _nvrtc_name       # Source filepath given to NVRTC; a real path for debug builds
+        bytes _debug_source     # Temp file this Program wrote for cuda-gdb, or None
         list _extra_options     # NVRTC options Program adds on top of ProgramOptions