Merge remote-tracking branch 'upstream/main' into cuda.core.system-events

Author: mdboom

cuda_bindings/cuda/bindings/_lib/utils.pxd.in

@@ -50,6 +50,7 @@ cdef class _HelperCUpointer_attribute:
     # Return values
     cdef driver.CUcontext _ctx
     cdef unsigned int _uint
+    cdef int _int
     cdef driver.CUdeviceptr _devptr
     cdef void** _void
     cdef driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS _token

cuda_bindings/cuda/bindings/_lib/utils.pxi.in

@@ -247,12 +247,14 @@ cdef class _HelperCUpointer_attribute:
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
         elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMORY_TYPE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,{{endif}}
                             {{if 'CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,{{endif}}
                             {{if 'CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,{{endif}}
                             {{if 'CU_POINTER_ATTRIBUTE_ACCESS_FLAGS'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,{{endif}}):
             self._uint = init_value
             self._cptr = <void*>&self._uint
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,{{endif}}):
+            self._int = init_value
+            self._cptr = <void*>&self._int
         elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_DEVICE_POINTER'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER,{{endif}}
                             {{if 'CU_POINTER_ATTRIBUTE_RANGE_START_ADDR'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,{{endif}}):
             if self._is_getter:

cuda_bindings/docs/source/release/13.1.X-notes.rst

@@ -0,0 +1,26 @@
+.. SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+.. SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+.. module:: cuda.bindings
+
+``cuda-bindings`` 13.1.X Release notes
+======================================
+
+Highlights
+----------
+
+Experimental
+------------
+
+Bugfixes
+--------
+
+* Fixed an issue where the ``CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL`` attribute was
+  retrieved as an unsigned int, rather than a signed int.
+  (`PR #1336 <https://github.com/NVIDIA/cuda-python/pull/1336>`_)
+
+Known issues
+------------
+
+* Updating from older versions (v12.6.2.post1 and below) via ``pip install -U cuda-python`` might not work. Please do a clean re-installation by uninstalling ``pip uninstall -y cuda-python`` followed by installing ``pip install cuda-python``.
+* The graphics APIs in ``cuda.bindings.runtime`` are inadvertently disabled in 13.0.2.  Users needing these APIs should update to 13.0.3.

cuda_bindings/tests/test_cuda.py

@@ -370,6 +370,22 @@ def test_cuda_pointer_attr():
     assert err == cuda.CUresult.CUDA_SUCCESS
 
 
+@pytest.mark.skipif(
+    driverVersionLessThan(11030) or not supportsManagedMemory(), reason="When new attributes were introduced"
+)
+def test_pointer_get_attributes_device_ordinal():
+    attributes = [
+        cuda.CUpointer_attribute.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,
+    ]
+
+    attrs = cuda.cuPointerGetAttributes(len(attributes), attributes, 0)
+
+    # device ordinals are always small numbers.  A large number would indicate
+    # an overflow error.
+
+    assert abs(attrs[1][0]) < 256
+
+
 @pytest.mark.skipif(not supportsManagedMemory(), reason="When new attributes were introduced")
 def test_cuda_mem_range_attr(device):
     size = 0x1000

cuda_core/cuda/core/system/_device.pyx

@@ -15,6 +15,7 @@ from ._nvml_context cimport initialize
 include "_device_utils.pxi"
 
 
+BrandType = nvml.BrandType
 EventType = nvml.EventType
 FieldId = nvml.FieldId
 
@@ -307,6 +308,77 @@ cdef class DeviceEvents:
         return EventData(nvml.event_set_wait_v2(self._event_set, timeout_ms))
 
 
+cdef class DeviceAttributes:
+    """
+    Various device attributes.
+    """
+    def __init__(self, attributes: nvml.DeviceAttributes):
+        self._attributes = attributes
+
+    @property
+    def multiprocessor_count(self) -> int:
+        """
+        The streaming multiprocessor count
+        """
+        return self._attributes.multiprocessor_count
+
+    @property
+    def shared_copy_engine_count(self) -> int:
+        """
+        The shared copy engine count
+        """
+        return self._attributes.shared_copy_engine_count
+
+    @property
+    def shared_decoder_count(self) -> int:
+        """
+        The shared decoder engine count
+        """
+        return self._attributes.shared_decoder_count
+
+    @property
+    def shared_encoder_count(self) -> int:
+        """
+        The shared encoder engine count
+        """
+        return self._attributes.shared_encoder_count
+
+    @property
+    def shared_jpeg_count(self) -> int:
+        """
+        The shared JPEG engine count
+        """
+        return self._attributes.shared_jpeg_count
+
+    @property
+    def shared_ofa_count(self) -> int:
+        """
+        The shared optical flow accelerator (OFA) engine count
+        """
+        return self._attributes.shared_ofa_count
+
+    @property
+    def gpu_instance_slice_count(self) -> int:
+        """
+        The GPU instance slice count
+        """
+        return self._attributes.gpu_instance_slice_count
+
+    @property
+    def compute_instance_slice_count(self) -> int:
+        """
+        The compute instance slice count
+        """
+        return self._attributes.compute_instance_slice_count
+
+    @property
+    def memory_size_mb(self) -> int:
+        """
+        Device memory size in MiB
+        """
+        return self._attributes.memory_size_mb
+
+
 cdef class FieldValue:
     """
     Represents the data from a single field value.
@@ -450,45 +522,64 @@ cdef class Device:
     about devices and their topology, as provided by the NVIDIA Management
     Library (NVML).  To use CUDA with a device, use :class:`cuda.core.Device`.
 
+    Creating a device instance causes NVML to initialize the target GPU.
+    NVML may initialize additional GPUs if the target GPU is an SLI slave.
+
     Parameters
     ----------
     index: int, optional
-        Integer representing the CUDA device index to get a handle to.
+        Integer representing the CUDA device index to get a handle to.  Valid
+        values are between ``0`` and ``cuda.core.system.get_num_devices() - 1``.
+
+        The order in which devices are enumerated has no guarantees of
+        consistency between reboots.  For that reason, it is recommended that
+        devices are looked up by their PCI ids or UUID.
+
     uuid: bytes or str, optional
         UUID of a CUDA device to get a handle to.
 
+    pci_bus_id: bytes or str, optional
+        PCI bus ID of a CUDA device to get a handle to.
+
     Raises
     ------
     ValueError
-        If neither `index` nor `uuid` are specified or if both are specified.
+        If anything other than a single `index`, `uuid` or `pci_bus_id` are specified.
     """
 
     cdef intptr_t _handle
 
-    def __init__(self, index: int | None = None, uuid: bytes | str | None = None, handle: int | None = None):
+    def __init__(
+        self,
+        *,
+        index: int | None = None,
+        uuid: bytes | str | None = None,
+        pci_bus_id: bytes | str | None = None,
+        handle: int | None = None
+    ):
         initialize()
 
-        args = [index, uuid, handle]
+        args = [index, uuid, pci_bus_id, handle]
         cdef int arg_count = sum(arg is not None for arg in args)
 
         if arg_count > 1:
-            raise ValueError("Handle requires only one of `index`, `uuid` or `handle`.")
+            raise ValueError("Handle requires only one of `index`, `uuid`, `pci_bus_id` or `handle`.")
         if arg_count == 0:
-            raise ValueError("Handle requires either a device `index` or `uuid`.")
+            raise ValueError("Handle requires either a device `index`, `pci_bus_id`, or `uuid`.")
 
         if index is not None:
             self._handle = nvml.device_get_handle_by_index_v2(index)
         elif uuid is not None:
             if isinstance(uuid, bytes):
                 uuid = uuid.decode("ascii")
             self._handle = nvml.device_get_handle_by_uuid(uuid)
+        elif pci_bus_id is not None:
+            if isinstance(pci_bus_id, bytes):
+                pci_bus_id = pci_bus_id.decode("ascii")
+            self._handle = nvml.device_get_handle_by_pci_bus_id_v2(pci_bus_id)
         elif handle is not None:
             self._handle = handle
 
-    @property
-    def handle(self) -> int:
-        return self._handle
-
     @classmethod
     def get_all_devices(cls) -> Iterable[Device]:
         """
@@ -501,7 +592,7 @@ cdef class Device:
         """
         total = nvml.device_get_count_v2()
         for device_id in range(total):
-            yield cls(device_id)
+            yield cls(index=device_id)
 
     @property
     def architecture(self) -> DeviceArchitecture:
@@ -565,6 +656,24 @@ cdef class Device:
         """
         return nvml.device_get_name(self._handle)
 
+    @property
+    def brand(self) -> BrandType:
+        """
+        Brand of the device
+        """
+        return BrandType(nvml.device_get_brand(self._handle))
+
+    @property
+    def index(self) -> int:
+        """
+        The NVML index of this device.
+
+        The order in which NVML enumerates devices has no guarantees of
+        consistency between reboots. For that reason it is recommended that
+        devices be looked up by their PCI ids or GPU UUID.
+        """
+        return nvml.device_get_index(self._handle)
+
     @property
     def pci_info(self) -> PciInfo:
         """
@@ -647,6 +756,39 @@ cdef class Device:
         bitmask[0] = nvml.device_get_supported_event_types(self._handle)
         return [EventType(1 << ev) for ev in _unpack_bitmask(bitmask)]
 
+    @property
+    def attributes(self) -> DeviceAttributes:
+        """
+        Get various device attributes.
+
+        For Ampere™ or newer fully supported devices.  Only available on Linux
+        systems.
+        """
+        return DeviceAttributes(nvml.device_get_attributes_v2(self._handle))
+
+    @property
+    def is_c2c_mode_enabled(self) -> bool:
+        """
+        Whether the C2C (Chip-to-Chip) mode is enabled for this device.
+        """
+        return bool(nvml.device_get_c2c_mode_info_v(self._handle).is_c2c_enabled)
+
+    @property
+    def persistence_mode_enabled(self) -> bool:
+        """
+        Whether persistence mode is enabled for this device.
+
+        For Linux only.
+        """
+        return nvml.device_get_persistence_mode(self._handle) == nvml.EnableState.FEATURE_ENABLED
+
+    @persistence_mode_enabled.setter
+    def persistence_mode_enabled(self, enabled: bool) -> None:
+        nvml.device_set_persistence_mode(
+            self._handle,
+            nvml.EnableState.FEATURE_ENABLED if enabled else nvml.EnableState.FEATURE_DISABLED
+        )
+
     def get_field_values(self, field_ids: list[int | tuple[int, int]]) -> FieldValues:
         """
         Get multiple field values from the device.
@@ -690,8 +832,10 @@ cdef class Device:
 
 __all__ = [
     "BAR1MemoryInfo",
+    "BrandType",
     "Device",
     "DeviceArchitecture",
+    "DeviceAttributes",
     "DeviceEvents",
     "EventData",
     "EventType",

cuda_core/docs/source/api.rst

@@ -89,18 +89,19 @@ CUDA system information and NVIDIA Management Library (NVML)
    :template: autosummary/cyclass.rst
 
    system.Device
+   system.BAR1MemoryInfo
+   system.BrandType
    system.DeviceArchitecture
+   system.DeviceAttributes
    system.DeviceEvents
    system.EventData
    system.EventType
    system.FieldId
    system.FieldValue
    system.FieldValues
    system.MemoryInfo
-   system.BAR1MemoryInfo
    system.PciInfo
 
-
 .. module:: cuda.core.utils
 
 Utility functions