Merge remote-tracking branch 'upstream/main' into pyi-experiment

Author: mdboom

.github/workflows/release.yml

@@ -101,10 +101,10 @@ jobs:
         with:
           python-version: "3.12"
 
-      - name: Self-test release-notes checker
-        run: |
-          pip install pytest
-          pytest ci/tools/tests
+      # - name: Self-test release-notes checker
+      #   run: |
+      #     pip install pytest
+      #     pytest ci/tools/tests
 
       - name: Check versioned release notes exist
         run: |

.github/workflows/test-wheel-linux.yml

@@ -130,21 +130,21 @@ jobs:
           path: ./cuda_pathfinder
 
       - name: Download cuda-python build artifacts
-        if: ${{ env.USE_BACKPORT_BINDINGS == '0' }}
+        if: ${{ env.BINDINGS_SOURCE == 'main' }}
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
         with:
           name: cuda-python-wheel
           path: .
 
       - name: Download cuda.bindings build artifacts
-        if: ${{ env.USE_BACKPORT_BINDINGS == '0' }}
+        if: ${{ env.BINDINGS_SOURCE == 'main' }}
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
         with:
           name: ${{ env.CUDA_BINDINGS_ARTIFACT_NAME }}
           path: ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}
 
       - name: Download cuda-python & cuda.bindings build artifacts from the prior branch
-        if: ${{ env.USE_BACKPORT_BINDINGS == '1' }}
+        if: ${{ env.BINDINGS_SOURCE == 'backport' }}
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
@@ -184,6 +184,7 @@ jobs:
           ls -lahR .
 
       - name: Display structure of downloaded cuda.bindings artifacts
+        if: ${{ env.BINDINGS_SOURCE != 'published' }}
         run: |
           pwd
           ls -lahR $CUDA_BINDINGS_ARTIFACTS_DIR
@@ -285,6 +286,7 @@ jobs:
         run: run-tests core
 
       - name: Ensure cuda-python installable
+        if: ${{ env.BINDINGS_SOURCE == 'main' }}
         run: |
           if [[ "${{ matrix.LOCAL_CTK }}" == 1 ]]; then
             pip install --only-binary=:all: cuda_python*.whl

.github/workflows/test-wheel-windows.yml

@@ -125,21 +125,21 @@ jobs:
           path: ./cuda_pathfinder
 
       - name: Download cuda-python build artifacts
-        if: ${{ env.USE_BACKPORT_BINDINGS == '0' }}
+        if: ${{ env.BINDINGS_SOURCE == 'main' }}
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
         with:
           name: cuda-python-wheel
           path: .
 
       - name: Download cuda.bindings build artifacts
-        if: ${{ env.USE_BACKPORT_BINDINGS == '0' }}
+        if: ${{ env.BINDINGS_SOURCE == 'main' }}
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
         with:
           name: ${{ env.CUDA_BINDINGS_ARTIFACT_NAME }}
           path: ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}
 
       - name: Download cuda-python & cuda.bindings build artifacts from the prior branch
-        if: ${{ env.USE_BACKPORT_BINDINGS == '1' }}
+        if: ${{ env.BINDINGS_SOURCE == 'backport' }}
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
@@ -170,6 +170,7 @@ jobs:
           Get-ChildItem -Recurse -Force | Select-Object Mode, LastWriteTime, Length, FullName
 
       - name: Display structure of downloaded cuda.bindings artifacts
+        if: ${{ env.BINDINGS_SOURCE != 'published' }}
         run: |
           Get-Location
           Get-ChildItem -Recurse -Force $env:CUDA_BINDINGS_ARTIFACTS_DIR | Select-Object Mode, LastWriteTime, Length, FullName
@@ -261,6 +262,7 @@ jobs:
         run: run-tests core
 
       - name: Ensure cuda-python installable
+        if: ${{ env.BINDINGS_SOURCE == 'main' }}
         run: |
           if ('${{ matrix.LOCAL_CTK }}' -eq '1') {
             pip install --only-binary=:all: (Get-ChildItem -Filter cuda_python*.whl).FullName

ci/tools/env-vars

@@ -52,34 +52,38 @@ 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_ARTIFACT_BASENAME="cuda-bindings-python${PYTHON_VERSION_FORMATTED}-cuda${BUILD_CUDA_VER}-${HOST_PLATFORM}"
-  # USE_BACKPORT_BINDINGS flags the CTK-major-mismatch case where the
-  # current-run bindings wheel was built for a different CTK major than the
-  # one under test, so we must pull the bindings wheel from the backport
-  # branch instead. This is independent of whether bindings tests run.
-  # SKIP_CUDA_BINDINGS_TEST is the test-time gate: it is set when the CTK
-  # majors differ OR when the caller tells us to skip for path-filter
-  # reasons via SKIP_BINDINGS_TEST_OVERRIDE.
+
+  # BINDINGS_SOURCE controls which cuda-bindings to install at test time:
+  #   main      — use the just-built bindings wheel from this CI run
+  #   backport  — fetch bindings from the prior (N-1) branch
+  #   published — install from PyPI (cuda-bindings==${TEST_CUDA_MAJOR}.${TEST_CUDA_MINOR}.*)
+  #
+  # SKIP_CUDA_BINDINGS_TEST / SKIP_CYTHON_TEST control which *tests* to run
+  # (they do NOT affect installation — that's BINDINGS_SOURCE's job).
+
+  BUILD_CUDA_MINOR="$(cut -d '.' -f 2 <<< ${BUILD_CUDA_VER})"
+  TEST_CUDA_MINOR="$(cut -d '.' -f 2 <<< ${CUDA_VER})"
+
   if [[ ${BUILD_CUDA_MAJOR} != ${TEST_CUDA_MAJOR} ]]; then
-    USE_BACKPORT_BINDINGS=1
+    # Major mismatch (e.g. build=13.x, test=12.x): use the backport branch.
+    BINDINGS_SOURCE=backport
+    SKIP_CUDA_BINDINGS_TEST=1
+    SKIP_CYTHON_TEST=1
+  elif [[ ${BUILD_CUDA_MINOR} != ${TEST_CUDA_MINOR} ]]; then
+    # Same major, minor mismatch (e.g. build=13.2, test=13.0): use published
+    # bindings from PyPI to test the real-world backward-compat scenario.
+    BINDINGS_SOURCE=published
     SKIP_CUDA_BINDINGS_TEST=1
     SKIP_CYTHON_TEST=1
   else
-    USE_BACKPORT_BINDINGS=0
-    # Path-filter override only skips bindings tests, NOT cython tests
-    # for other modules (e.g. cuda.core). Cython skip is driven solely
-    # by the build/test CTK minor-version mismatch.
+    # Exact match: use the just-built bindings wheel.
+    BINDINGS_SOURCE=main
     if [[ "${SKIP_BINDINGS_TEST_OVERRIDE:-0}" == "1" ]]; then
       SKIP_CUDA_BINDINGS_TEST=1
     else
       SKIP_CUDA_BINDINGS_TEST=0
     fi
-    BUILD_CUDA_MINOR="$(cut -d '.' -f 2 <<< ${BUILD_CUDA_VER})"
-    TEST_CUDA_MINOR="$(cut -d '.' -f 2 <<< ${CUDA_VER})"
-    if [[ ${BUILD_CUDA_MINOR} != ${TEST_CUDA_MINOR} ]]; then
-      SKIP_CYTHON_TEST=1
-    else
-      SKIP_CYTHON_TEST=0
-    fi
+    SKIP_CYTHON_TEST=0
   fi
   # We don't test compute-sanitizer on CTK<12 because backporting fixes is too much effort
   # We only test compute-sanitizer on python 3.12 arbitrarily; we don't need to use sanitizer on the entire matrix
@@ -93,10 +97,11 @@ elif [[ "${1}" == "test" ]]; then
   fi
   {
     echo "SETUP_SANITIZER=${SETUP_SANITIZER}"
+    echo "BINDINGS_SOURCE=${BINDINGS_SOURCE}"
     echo "SKIP_CUDA_BINDINGS_TEST=${SKIP_CUDA_BINDINGS_TEST}"
     echo "SKIP_CYTHON_TEST=${SKIP_CYTHON_TEST}"
     echo "TEST_CUDA_MAJOR=${TEST_CUDA_MAJOR}"
-    echo "USE_BACKPORT_BINDINGS=${USE_BACKPORT_BINDINGS}"
+    echo "TEST_CUDA_MINOR=${TEST_CUDA_MINOR}"
   } >> $GITHUB_ENV
 fi
 

ci/tools/run-tests

@@ -54,10 +54,12 @@ elif [[ "${test_module}" == "bindings" ]]; then
   fi
   popd
 elif [[ "${test_module}" == "core" ]]; then
-  # If build/test majors match: cuda.bindings is installed in the previous step.
-  # If mismatch: cuda.bindings is installed from the backport branch.
-  if [[ "${SKIP_CUDA_BINDINGS_TEST}" == 1 ]]; then
-    echo "Installing bindings wheel"
+  # Install cuda.bindings for core tests based on BINDINGS_SOURCE.
+  if [[ "${BINDINGS_SOURCE}" == "published" ]]; then
+    echo "Installing published cuda-bindings==${TEST_CUDA_MAJOR}.${TEST_CUDA_MINOR}.* from PyPI"
+    pip install "cuda-bindings==${TEST_CUDA_MAJOR}.${TEST_CUDA_MINOR}.*"
+  elif [[ "${BINDINGS_SOURCE}" == "backport" || "${BINDINGS_SOURCE}" == "main" ]]; then
+    echo "Installing bindings wheel (source: ${BINDINGS_SOURCE})"
     if [[ "${LOCAL_CTK}" == 1 ]]; then
       pip install "${CUDA_BINDINGS_ARTIFACTS_DIR}"/*.whl
     else
@@ -83,6 +85,8 @@ elif [[ "${test_module}" == "core" ]]; then
   # Constrain cuda-toolkit to the requested CTK version to avoid
   # pip pulling in a newer nvidia-cuda-runtime that conflicts with it.
   pip install "${WHL_EXTRA[@]}" --group "test-cu${TEST_CUDA_MAJOR}${FREE_THREADING}" "cuda-toolkit==${CUDA_VER_MINOR}.*"
+  echo "Installed packages before core tests:"
+  pip list
   echo "Running core tests"
   ${SANITIZER_CMD} pytest -rxXs -v --durations=0 --randomly-dont-reorganize tests/
   # Currently our CI always installs the latest bindings (from either major version).

cuda_bindings/tests/nvml/conftest.py

@@ -106,8 +106,23 @@ def nmigs(handles):
 
 @pytest.fixture
 def mig_handles(nmigs):
-    handles = [nvml.device_get_mig_device_handle_by_index(i) for i in range(nmigs)]
-    assert len(handles) == nmigs
+    handles = []
+    with NVMLInitializer():
+        dev_count = nvml.device_get_count_v2()
+
+        for dev_idx in range(dev_count):
+            try:
+                dev = nvml.device_get_handle_by_index_v2(dev_idx)
+            except nvml.NoPermissionError:
+                continue
+            for mig_idx in range(nmigs):
+                try:
+                    mig = nvml.device_get_mig_device_handle_by_index(dev, mig_idx)
+                except nvml.NotFoundError:
+                    # Not all MIG devices may be available
+                    continue
+                else:
+                    handles.append(mig)
     return handles
 
 

cuda_bindings/tests/nvml/test_cuda.py

@@ -3,6 +3,8 @@
 
 import os
 
+import pytest
+
 import cuda.bindings.driver as cuda
 from cuda.bindings import nvml
 
@@ -56,6 +58,10 @@ def test_cuda_device_order():
     cuda_devices = get_cuda_device_names()
     nvml_devices = get_nvml_device_names()
 
+    if any("Thor" in device["name"] for device in nvml_devices):
+        pytest.skip("Skipping test on Thor, which has non-standard device naming")
+        return
+
     if "CUDA_VISIBLE_DEVICES" not in os.environ:
         # If that environment variable isn't set, the device lists should match exactly
         assert cuda_devices == nvml_devices, "CUDA and NVML device lists do not match"

cuda_bindings/tests/nvml/test_pynvml.py

@@ -187,7 +187,7 @@ def test_device_get_memory_info(ngpus, handles):
 
 def test_device_get_utilization_rates(ngpus, handles):
     for i in range(ngpus):
-        with unsupported_before(handles[i], "FERMI"):
+        with unsupported_before(handles[i], None):
             urate = nvml.device_get_utilization_rates(handles[i])
         assert urate.gpu >= 0
         assert urate.memory >= 0

cuda_core/cuda/core/__init__.py

@@ -28,6 +28,46 @@ def _import_versioned_module():
 del _import_versioned_module
 
 
+def _patch_rlcompleter_for_cython_properties():
+    # TODO: This can be removed when Python 3.13 is our minimum-supported version:
+    #   https://github.com/python/cpython/pull/149577
+
+    # Cython @property on cdef class compiles to a C-level getset_descriptor,
+    # which rlcompleter's narrow isinstance(..., property) check misses; the
+    # fallback getattr() then invokes the descriptor and any non-AttributeError
+    # it raises kills tab completion. Extend that isinstance check to also
+    # match getset_descriptor / member_descriptor. Only installed in
+    # interactive mode so library users running scripts see no global
+    # rlcompleter side effect.
+    import os
+
+    if int(os.environ.get("CUDA_CORE_DONT_FIX_TAB_COMPLETION", "0")):
+        # Explicit opt-out for users who don't want the global rlcompleter
+        # side effect, even in an interactive session.
+        return
+
+    import rlcompleter
+    from types import GetSetDescriptorType, MemberDescriptorType
+
+    # This works by overriding the `property` built-in with a custom subclass of
+    # property, but only in the rlcompleter module.  This subclass overrides the
+    # `__instancecheck__` method to also return True for getset_descriptor and
+    # member_descriptor types, which are what Cython uses for properties on cdef
+    # classes.
+    class _PatchedPropMeta(type):
+        def __instancecheck__(cls, inst):
+            return isinstance(inst, (property, GetSetDescriptorType, MemberDescriptorType))
+
+    class _PatchedProperty(metaclass=_PatchedPropMeta):
+        pass
+
+    rlcompleter.property = _PatchedProperty
+
+
+_patch_rlcompleter_for_cython_properties()
+del _patch_rlcompleter_for_cython_properties
+
+
 from cuda.core import checkpoint, system, utils
 from cuda.core._context import Context, ContextOptions
 from cuda.core._device import Device

cuda_core/cuda/core/_cpp/resource_handles.cpp

@@ -77,6 +77,13 @@ decltype(&cuLinkDestroy) p_cuLinkDestroy = nullptr;
 decltype(&cuGraphicsUnmapResources) p_cuGraphicsUnmapResources = nullptr;
 decltype(&cuGraphicsUnregisterResource) p_cuGraphicsUnregisterResource = nullptr;
 
+// SM resource split (13.1+ — may be null on older drivers/bindings)
+#if CUDA_VERSION >= 13010
+decltype(&cuDevSmResourceSplit) p_cuDevSmResourceSplit = nullptr;
+#else
+void* p_cuDevSmResourceSplit = nullptr;
+#endif
+
 // NVRTC function pointers
 decltype(&nvrtcDestroyProgram) p_nvrtcDestroyProgram = nullptr;
 
@@ -1319,4 +1326,27 @@ FileDescriptorHandle create_fd_handle_ref(int fd) {
 #endif
 }
 
+// ============================================================================
+// SM resource split wrapper
+// ============================================================================
+
+CUresult sm_resource_split(CUdevResource* result, unsigned int nbGroups,
+                           const CUdevResource* input, CUdevResource* remainder,
+                           unsigned int flags, void* groupParams) {
+#if CUDA_VERSION >= 13010
+    if (!p_cuDevSmResourceSplit) {
+        return CUDA_ERROR_NOT_SUPPORTED;
+    }
+    return p_cuDevSmResourceSplit(
+        result, nbGroups, input, remainder, flags,
+        static_cast<CU_DEV_SM_RESOURCE_GROUP_PARAMS*>(groupParams));
+#else
+    return CUDA_ERROR_NOT_SUPPORTED;
+#endif
+}
+
+bool has_sm_resource_split() noexcept {
+    return p_cuDevSmResourceSplit != nullptr;
+}
+
 }  // namespace cuda_core