Release Release v13.5.0 · NVIDIA/cuda-python

Highlights

New APIs from CTK 13.5:
- driver: cuFabricCpyBatchAsync, cuTensorMapSetAllocationClass, and the new
  CUtensorMapAllocClass and CUfabricCpyOperandType enums, along with the
  CUDA_FABRIC_COPY_BATCH_OP and CUDA_FABRIC_CPY_BATCH_NODE_PARAMS_V1 structs. There are
  new graph node types (CU_GRAPH_NODE_TYPE_MEMCPY_BATCH, CU_GRAPH_NODE_TYPE_EXTERNAL_ENGINE
  and CU_GRAPH_NODE_TYPE_FABRIC_CPY_BATCH), new device attributes
  (CU_DEVICE_ATTRIBUTE_VULKAN_CIG_STREAMS_SUPPORTED and
  CU_DEVICE_ATTRIBUTE_TENSOR_MAP_LARGE_TENSOR_MIN_SIZE), and a new
  CU_COREDUMP_SKIP_TENSOR_MEMORY coredump flag.
- runtime: cudaMemcpyBatchNodeParams.
- nvml: device_get_gpu_uptime_v1, system_get_conf_compute_settings_v2,
  device_get_nvlink_info_v3, device_get_nvlink_remap_table_info_v1,
  device_set_nvlink_nvle_ready_v1, device_lock_nvlink_remap_table_v1,
  device_setup_nvlink_nvle_encryption_key_v1 and device_get_nvlink_nvle_private_info_v1.
- cufile: PANFS_SUPPORTED capability flag.
- nvvm: the -nvvm-latest compiler option is documented.
Python 3.10 support was dropped (end of life). Python 3.15 is now officially supported.

Changes

Many cuda.bindings.cudla and cuda.bindings.nvml enum members had a
redundant prefix stripped from their name,
e.g. nvml.BrandType.BRAND_GEFORCE is now nvml.BrandType.GEFORCE.
The old, longer names remain available as backward-compatible aliases and
will continue to work. The full list of renames, excluding the 447
similarly-renamed nvml.GpmMetricId members (which had their
GPM_METRIC_ prefix stripped the same way), is below.
In addition, the members of cudla.Status are now PEP8-compliant
SHOUT_CASE (e.g. ErrorInvalidParam is now ERROR_INVALID_PARAM); the old
names remain available as backward-compatible aliases. That enum is not
included in the table below.

Enum member renames (old names remain available as backward-compatible aliases)

Module	Enum class	New name	Deprecated alias
`cudla`	`FenceType`	`FENCE`	`NVSCISYNC_FENCE`
`cudla`	`FenceType`	`FENCE_SOF`	`NVSCISYNC_FENCE_SOF`
`cudla`	`ModuleLoadFlags`	`DEFAULT`	`MODULE_DEFAULT`
`cudla`	`ModuleLoadFlags`	`ENABLE_FAULT_DIAGNOSTICS`	`MODULE_ENABLE_FAULT_DIAGNOSTICS`
`cudla`	`ScratchMemoryConfig`	`CONFIG_MAX`	`MAX`
`cudla`	`ScratchMemoryConfig`	`DEFAULT`	`SCRATCH_MEMORY_DEFAULT`
`cudla`	`ScratchMemoryConfig`	`SHARED_STATIC`	`SCRATCH_MEMORY_SHARED_STATIC`
`cudla`	`SubmissionFlags`	`DIAGNOSTICS_TASK`	`SUBMIT_DIAGNOSTICS_TASK`
`cudla`	`SubmissionFlags`	`NOOP`	`SUBMIT_NOOP`
`cudla`	`SubmissionFlags`	`SKIP_LOCK_ACQUIRE`	`SUBMIT_SKIP_LOCK_ACQUIRE`
`nvml`	`BrandType`	`COUNT`	`BRAND_COUNT`
`nvml`	`BrandType`	`GEFORCE`	`BRAND_GEFORCE`
`nvml`	`BrandType`	`GEFORCE_RTX`	`BRAND_GEFORCE_RTX`
`nvml`	`BrandType`	`GRID`	`BRAND_GRID`
`nvml`	`BrandType`	`NVIDIA`	`BRAND_NVIDIA`
`nvml`	`BrandType`	`NVIDIA_CLOUD_GAMING`	`BRAND_NVIDIA_CLOUD_GAMING`
`nvml`	`BrandType`	`NVIDIA_DLA`	`BRAND_NVIDIA_DLA`
`nvml`	`BrandType`	`NVIDIA_NPU`	`BRAND_NVIDIA_NPU`
`nvml`	`BrandType`	`NVIDIA_RTX`	`BRAND_NVIDIA_RTX`
`nvml`	`BrandType`	`NVIDIA_VAPPS`	`BRAND_NVIDIA_VAPPS`
`nvml`	`BrandType`	`NVIDIA_VCS`	`BRAND_NVIDIA_VCS`
`nvml`	`BrandType`	`NVIDIA_VGAMEDEV`	`BRAND_NVIDIA_VGAMEDEV`
`nvml`	`BrandType`	`NVIDIA_VGAMING`	`BRAND_NVIDIA_VGAMING`
`nvml`	`BrandType`	`NVIDIA_VPC`	`BRAND_NVIDIA_VPC`
`nvml`	`BrandType`	`NVIDIA_VWS`	`BRAND_NVIDIA_VWS`
`nvml`	`BrandType`	`NVS`	`BRAND_NVS`
`nvml`	`BrandType`	`QUADRO`	`BRAND_QUADRO`
`nvml`	`BrandType`	`QUADRO_RTX`	`BRAND_QUADRO_RTX`
`nvml`	`BrandType`	`TESLA`	`BRAND_TESLA`
`nvml`	`BrandType`	`TITAN`	`BRAND_TITAN`
`nvml`	`BrandType`	`TITAN_RTX`	`BRAND_TITAN_RTX`
`nvml`	`BrandType`	`UNKNOWN`	`BRAND_UNKNOWN`
`nvml`	`BridgeChipType`	`BRO4`	`BRIDGE_CHIP_BRO4`
`nvml`	`BridgeChipType`	`PLX`	`BRIDGE_CHIP_PLX`
`nvml`	`ClockType`	`COUNT`	`CLOCK_COUNT`
`nvml`	`ClockType`	`GRAPHICS`	`CLOCK_GRAPHICS`
`nvml`	`ClockType`	`MEM`	`CLOCK_MEM`
`nvml`	`ClockType`	`SM`	`CLOCK_SM`
`nvml`	`ClockType`	`VIDEO`	`CLOCK_VIDEO`
`nvml`	`ComputeMode`	`COUNT`	`COMPUTEMODE_COUNT`
`nvml`	`ComputeMode`	`DEFAULT`	`COMPUTEMODE_DEFAULT`
`nvml`	`ComputeMode`	`EXCLUSIVE_PROCESS`	`COMPUTEMODE_EXCLUSIVE_PROCESS`
`nvml`	`ComputeMode`	`EXCLUSIVE_THREAD`	`COMPUTEMODE_EXCLUSIVE_THREAD`
`nvml`	`ComputeMode`	`PROHIBITED`	`COMPUTEMODE_PROHIBITED`
`nvml`	`CoolerControl`	`COUNT`	`THERMAL_COOLER_SIGNAL_COUNT`
`nvml`	`CoolerControl`	`NONE`	`THERMAL_COOLER_SIGNAL_NONE`
`nvml`	`CoolerControl`	`TOGGLE`	`THERMAL_COOLER_SIGNAL_TOGGLE`
`nvml`	`CoolerControl`	`VARIABLE`	`THERMAL_COOLER_SIGNAL_VARIABLE`
`nvml`	`CoolerTarget`	`GPU`	`THERMAL_GPU`
`nvml`	`CoolerTarget`	`GPU_RELATED`	`THERMAL_GPU_RELATED`
`nvml`	`CoolerTarget`	`MEMORY`	`THERMAL_MEMORY`
`nvml`	`CoolerTarget`	`NONE`	`THERMAL_NONE`
`nvml`	`CoolerTarget`	`POWER_SUPPLY`	`THERMAL_POWER_SUPPLY`
`nvml`	`DetachGpuState`	`KEEP`	`DETACH_GPU_KEEP`
`nvml`	`DetachGpuState`	`REMOVE`	`DETACH_GPU_REMOVE`
`nvml`	`DeviceAddressingModeType`	`ATS`	`DEVICE_ADDRESSING_MODE_ATS`
`nvml`	`DeviceAddressingModeType`	`HMM`	`DEVICE_ADDRESSING_MODE_HMM`
`nvml`	`DeviceAddressingModeType`	`NONE`	`DEVICE_ADDRESSING_MODE_NONE`
`nvml`	`DeviceGpuRecoveryAction`	`BUS_RESET`	`GPU_RECOVERY_ACTION_BUS_RESET`
`nvml`	`DeviceGpuRecoveryAction`	`DRAIN_AND_RESET`	`GPU_RECOVERY_ACTION_DRAIN_AND_RESET`
`nvml`	`DeviceGpuRecoveryAction`	`DRAIN_P2P`	`GPU_RECOVERY_ACTION_DRAIN_P2P`
`nvml`	`DeviceGpuRecoveryAction`	`GPU_RESET`	`GPU_RECOVERY_ACTION_GPU_RESET`
`nvml`	`DeviceGpuRecoveryAction`	`NODE_REBOOT`	`GPU_RECOVERY_ACTION_NODE_REBOOT`
`nvml`	`DeviceGpuRecoveryAction`	`NONE`	`GPU_RECOVERY_ACTION_NONE`
`nvml`	`DeviceGpuRecoveryAction`	`RECOVER_IMEX_DOMAIN`	`GPU_RECOVERY_ACTION_RECOVER_IMEX_DOMAIN`
`nvml`	`DeviceGpuRecoveryAction`	`SYSTEM_REBOOT`	`GPU_RECOVERY_ACTION_SYSTEM_REBOOT`
`nvml`	`DeviceVgpuCapability`	`COMPUTE_MEDIA_ENGINE_GPU`	`DEVICE_VGPU_CAP_COMPUTE_MEDIA_ENGINE_GPU`
`nvml`	`DeviceVgpuCapability`	`COUNT`	`DEVICE_VGPU_CAP_COUNT`
`nvml`	`DeviceVgpuCapability`	`DEVICE_STREAMING`	`DEVICE_VGPU_CAP_DEVICE_STREAMING`
`nvml`	`DeviceVgpuCapability`	`FRACTIONAL_MULTI_VGPU`	`DEVICE_VGPU_CAP_FRACTIONAL_MULTI_VGPU`
`nvml`	`DeviceVgpuCapability`	`HETEROGENEOUS_TIMESLICE_PROFILES`	`DEVICE_VGPU_CAP_HETEROGENEOUS_TIMESLICE_PROFILES`
`nvml`	`DeviceVgpuCapability`	`HETEROGENEOUS_TIMESLICE_SIZES`	`DEVICE_VGPU_CAP_HETEROGENEOUS_TIMESLICE_SIZES`
`nvml`	`DeviceVgpuCapability`	`HOMOGENEOUS_PLACEMENTS`	`DEVICE_VGPU_CAP_HOMOGENEOUS_PLACEMENTS`
`nvml`	`DeviceVgpuCapability`	`MIG_TIMESLICING_ENABLED`	`DEVICE_VGPU_CAP_MIG_TIMESLICING_ENABLED`
`nvml`	`DeviceVgpuCapability`	`MIG_TIMESLICING_SUPPORTED`	`DEVICE_VGPU_CAP_MIG_TIMESLICING_SUPPORTED`
`nvml`	`DeviceVgpuCapability`	`MINI_QUARTER_GPU`	`DEVICE_VGPU_CAP_MINI_QUARTER_GPU`
`nvml`	`DeviceVgpuCapability`	`READ_DEVICE_BUFFER_BW`	`DEVICE_VGPU_CAP_READ_DEVICE_BUFFER_BW`
`nvml`	`DeviceVgpuCapability`	`WARM_UPDATE`	`DEVICE_VGPU_CAP_WARM_UPDATE`
`nvml`	`DeviceVgpuCapability`	`WRITE_DEVICE_BUFFER_BW`	`DEVICE_VGPU_CAP_WRITE_DEVICE_BUFFER_BW`
`nvml`	`DriverModel`	`MCDM`	`DRIVER_MCDM`
`nvml`	`DriverModel`	`WDDM`	`DRIVER_WDDM`
`nvml`	`DriverModel`	`WDM`	`DRIVER_WDM`
`nvml`	`EccCounterType`	`ECC_COUNTER_TYPE_COUNT`	`COUNT`
`nvml`	`EnableState`	`DISABLED`	`FEATURE_DISABLED`
`nvml`	`EnableState`	`ENABLED`	`FEATURE_ENABLED`
`nvml`	`EncoderType`	`AV1`	`ENCODER_QUERY_AV1`
`nvml`	`EncoderType`	`H264`	`ENCODER_QUERY_H264`
`nvml`	`EncoderType`	`HEVC`	`ENCODER_QUERY_HEVC`
`nvml`	`EncoderType`	`UNKNOWN`	`ENCODER_QUERY_UNKNOWN`
`nvml`	`EventDataType`	`NVML_EVENT`	`EVENT`
`nvml`	`FanState`	`FAILED`	`FAN_FAILED`
`nvml`	`FanState`	`NORMAL`	`FAN_NORMAL`
`nvml`	`GpuOperationMode`	`ALL_ON`	`GOM_ALL_ON`
`nvml`	`GpuOperationMode`	`COMPUTE`	`GOM_COMPUTE`
`nvml`	`GpuOperationMode`	`LOW_DP`	`GOM_LOW_DP`
`nvml`	`GpuP2PCapsIndex`	`ATOMICS`	`P2P_CAPS_INDEX_ATOMICS`
`nvml`	`GpuP2PCapsIndex`	`NVLINK`	`P2P_CAPS_INDEX_NVLINK`
`nvml`	`GpuP2PCapsIndex`	`PCI`	`P2P_CAPS_INDEX_PCI`
`nvml`	`GpuP2PCapsIndex`	`PROP`	`P2P_CAPS_INDEX_PROP`
`nvml`	`GpuP2PCapsIndex`	`READ`	`P2P_CAPS_INDEX_READ`
`nvml`	`GpuP2PCapsIndex`	`UNKNOWN`	`P2P_CAPS_INDEX_UNKNOWN`
`nvml`	`GpuP2PCapsIndex`	`WRITE`	`P2P_CAPS_INDEX_WRITE`
`nvml`	`GpuP2PStatus`	`CHIPSET_NOT_SUPPORED`	`P2P_STATUS_CHIPSET_NOT_SUPPORED`
`nvml`	`GpuP2PStatus`	`CHIPSET_NOT_SUPPORTED`	`P2P_STATUS_CHIPSET_NOT_SUPPORTED`
`nvml`	`GpuP2PStatus`	`DISABLED_BY_REGKEY`	`P2P_STATUS_DISABLED_BY_REGKEY`
`nvml`	`GpuP2PStatus`	`GPU_NOT_SUPPORTED`	`P2P_STATUS_GPU_NOT_SUPPORTED`
`nvml`	`GpuP2PStatus`	`IOH_TOPOLOGY_NOT_SUPPORTED`	`P2P_STATUS_IOH_TOPOLOGY_NOT_SUPPORTED`
`nvml`	`GpuP2PStatus`	`NOT_SUPPORTED`	`P2P_STATUS_NOT_SUPPORTED`
`nvml`	`GpuP2PStatus`	`OK`	`P2P_STATUS_OK`
`nvml`	`GpuP2PStatus`	`UNKNOWN`	`P2P_STATUS_UNKNOWN`
`nvml`	`GpuTopologyLevel`	`HOSTBRIDGE`	`TOPOLOGY_HOSTBRIDGE`
`nvml`	`GpuTopologyLevel`	`INTERNAL`	`TOPOLOGY_INTERNAL`
`nvml`	`GpuTopologyLevel`	`MULTIPLE`	`TOPOLOGY_MULTIPLE`
`nvml`	`GpuTopologyLevel`	`NODE`	`TOPOLOGY_NODE`
`nvml`	`GpuTopologyLevel`	`SINGLE`	`TOPOLOGY_SINGLE`
`nvml`	`GpuTopologyLevel`	`SYSTEM`	`TOPOLOGY_SYSTEM`
`nvml`	`GpuUtilizationDomainId`	`BUS`	`GPU_UTILIZATION_DOMAIN_BUS`
`nvml`	`GpuUtilizationDomainId`	`FB`	`GPU_UTILIZATION_DOMAIN_FB`
`nvml`	`GpuUtilizationDomainId`	`GPU`	`GPU_UTILIZATION_DOMAIN_GPU`
`nvml`	`GpuUtilizationDomainId`	`VID`	`GPU_UTILIZATION_DOMAIN_VID`
`nvml`	`InforomObject`	`COUNT`	`INFOROM_COUNT`
`nvml`	`InforomObject`	`DEN`	`INFOROM_DEN`
`nvml`	`InforomObject`	`ECC`	`INFOROM_ECC`
`nvml`	`InforomObject`	`OEM`	`INFOROM_OEM`
`nvml`	`InforomObject`	`POWER`	`INFOROM_POWER`
`nvml`	`IntNvLinkDeviceType`	`GPU`	`NVLINK_DEVICE_TYPE_GPU`
`nvml`	`IntNvLinkDeviceType`	`IBMNPU`	`NVLINK_DEVICE_TYPE_IBMNPU`
`nvml`	`IntNvLinkDeviceType`	`SWITCH`	`NVLINK_DEVICE_TYPE_SWITCH`
`nvml`	`IntNvLinkDeviceType`	`UNKNOWN`	`NVLINK_DEVICE_TYPE_UNKNOWN`
`nvml`	`NvLinkCapability`	`COUNT`	`NVLINK_CAP_COUNT`
`nvml`	`NvLinkCapability`	`P2P_ATOMICS`	`NVLINK_CAP_P2P_ATOMICS`
`nvml`	`NvLinkCapability`	`P2P_SUPPORTED`	`NVLINK_CAP_P2P_SUPPORTED`
`nvml`	`NvLinkCapability`	`SLI_BRIDGE`	`NVLINK_CAP_SLI_BRIDGE`
`nvml`	`NvLinkCapability`	`SYSMEM_ACCESS`	`NVLINK_CAP_SYSMEM_ACCESS`
`nvml`	`NvLinkCapability`	`SYSMEM_ATOMICS`	`NVLINK_CAP_SYSMEM_ATOMICS`
`nvml`	`NvLinkCapability`	`VALID`	`NVLINK_CAP_VALID`
`nvml`	`NvLinkErrorCounter`	`COUNT`	`NVLINK_ERROR_COUNT`
`nvml`	`NvLinkErrorCounter`	`DL_CRC_DATA`	`NVLINK_ERROR_DL_CRC_DATA`
`nvml`	`NvLinkErrorCounter`	`DL_CRC_FLIT`	`NVLINK_ERROR_DL_CRC_FLIT`
`nvml`	`NvLinkErrorCounter`	`DL_ECC_DATA`	`NVLINK_ERROR_DL_ECC_DATA`
`nvml`	`NvLinkErrorCounter`	`DL_RECOVERY`	`NVLINK_ERROR_DL_RECOVERY`
`nvml`	`NvLinkErrorCounter`	`DL_REPLAY`	`NVLINK_ERROR_DL_REPLAY`
`nvml`	`NvLinkUtilizationCountPktTypes`	`ALL`	`NVLINK_COUNTER_PKTFILTER_ALL`
`nvml`	`NvLinkUtilizationCountPktTypes`	`FLUSH`	`NVLINK_COUNTER_PKTFILTER_FLUSH`
`nvml`	`NvLinkUtilizationCountPktTypes`	`NOP`	`NVLINK_COUNTER_PKTFILTER_NOP`
`nvml`	`NvLinkUtilizationCountPktTypes`	`NRATOM`	`NVLINK_COUNTER_PKTFILTER_NRATOM`
`nvml`	`NvLinkUtilizationCountPktTypes`	`RATOM`	`NVLINK_COUNTER_PKTFILTER_RATOM`
`nvml`	`NvLinkUtilizationCountPktTypes`	`READ`	`NVLINK_COUNTER_PKTFILTER_READ`
`nvml`	`NvLinkUtilizationCountPktTypes`	`RESPDATA`	`NVLINK_COUNTER_PKTFILTER_RESPDATA`
`nvml`	`NvLinkUtilizationCountPktTypes`	`RESPNODATA`	`NVLINK_COUNTER_PKTFILTER_RESPNODATA`
`nvml`	`NvLinkUtilizationCountPktTypes`	`WRITE`	`NVLINK_COUNTER_PKTFILTER_WRITE`
`nvml`	`NvLinkUtilizationCountUnits`	`BYTES`	`NVLINK_COUNTER_UNIT_BYTES`
`nvml`	`NvLinkUtilizationCountUnits`	`COUNT`	`NVLINK_COUNTER_UNIT_COUNT`
`nvml`	`NvLinkUtilizationCountUnits`	`CYCLES`	`NVLINK_COUNTER_UNIT_CYCLES`
`nvml`	`NvLinkUtilizationCountUnits`	`PACKETS`	`NVLINK_COUNTER_UNIT_PACKETS`
`nvml`	`NvLinkUtilizationCountUnits`	`RESERVED`	`NVLINK_COUNTER_UNIT_RESERVED`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_1_0`	`VERSION_1_0`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_2_0`	`VERSION_2_0`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_2_2`	`VERSION_2_2`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_3_0`	`VERSION_3_0`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_3_1`	`VERSION_3_1`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_4_0`	`VERSION_4_0`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_5_0`	`VERSION_5_0`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_6_0`	`VERSION_6_0`
`nvml`	`NvlinkVersion`	`NVLINK_VERSION_INVALID`	`VERSION_INVALID`
`nvml`	`PcieLinkState`	`KEEP`	`PCIE_LINK_KEEP`
`nvml`	`PcieLinkState`	`SHUT_DOWN`	`PCIE_LINK_SHUT_DOWN`
`nvml`	`PcieUtilCounter`	`COUNT`	`PCIE_UTIL_COUNT`
`nvml`	`PcieUtilCounter`	`RX_BYTES`	`PCIE_UTIL_RX_BYTES`
`nvml`	`PcieUtilCounter`	`TX_BYTES`	`PCIE_UTIL_TX_BYTES`
`nvml`	`PerfPolicyType`	`BOARD_LIMIT`	`PERF_POLICY_BOARD_LIMIT`
`nvml`	`PerfPolicyType`	`COUNT`	`PERF_POLICY_COUNT`
`nvml`	`PerfPolicyType`	`LOW_UTILIZATION`	`PERF_POLICY_LOW_UTILIZATION`
`nvml`	`PerfPolicyType`	`POWER`	`PERF_POLICY_POWER`
`nvml`	`PerfPolicyType`	`RELIABILITY`	`PERF_POLICY_RELIABILITY`
`nvml`	`PerfPolicyType`	`SYNC_BOOST`	`PERF_POLICY_SYNC_BOOST`
`nvml`	`PerfPolicyType`	`THERMAL`	`PERF_POLICY_THERMAL`
`nvml`	`PerfPolicyType`	`TOTAL_APP_CLOCKS`	`PERF_POLICY_TOTAL_APP_CLOCKS`
`nvml`	`PerfPolicyType`	`TOTAL_BASE_CLOCKS`	`PERF_POLICY_TOTAL_BASE_CLOCKS`
`nvml`	`PowerProfileType`	`BALANCED`	`POWER_PROFILE_BALANCED`
`nvml`	`PowerProfileType`	`COMPUTE`	`POWER_PROFILE_COMPUTE`
`nvml`	`PowerProfileType`	`DCPCIE`	`POWER_PROFILE_DCPCIE`
`nvml`	`PowerProfileType`	`HIGH_THROUGHPUT_INFERENCE`	`POWER_PROFILE_HIGH_THROUGHPUT_INFERENCE`
`nvml`	`PowerProfileType`	`HMMA_DENSE`	`POWER_PROFILE_HMMA_DENSE`
`nvml`	`PowerProfileType`	`HMMA_SPARSE`	`POWER_PROFILE_HMMA_SPARSE`
`nvml`	`PowerProfileType`	`HPC`	`POWER_PROFILE_HPC`
`nvml`	`PowerProfileType`	`INFERENCE`	`POWER_PROFILE_INFERENCE`
`nvml`	`PowerProfileType`	`LLM_INFERENCE`	`POWER_PROFILE_LLM_INFERENCE`
`nvml`	`PowerProfileType`	`LLM_TRAINING`	`POWER_PROFILE_LLM_TRAINING`
`nvml`	`PowerProfileType`	`LOW_LATENCY_INFERENCE`	`POWER_PROFILE_LOW_LATENCY_INFERENCE`
`nvml`	`PowerProfileType`	`LOW_PRIORITY_BACKGROUND`	`POWER_PROFILE_LOW_PRIORITY_BACKGROUND`
`nvml`	`PowerProfileType`	`MAX`	`POWER_PROFILE_MAX`
`nvml`	`PowerProfileType`	`MAX_P`	`POWER_PROFILE_MAX_P`
`nvml`	`PowerProfileType`	`MAX_Q`	`POWER_PROFILE_MAX_Q`
`nvml`	`PowerProfileType`	`MAX_Q_1`	`POWER_PROFILE_MAX_Q_1`
`nvml`	`PowerProfileType`	`MAX_Q_2`	`POWER_PROFILE_MAX_Q_2`
`nvml`	`PowerProfileType`	`MAX_Q_3`	`POWER_PROFILE_MAX_Q_3`
`nvml`	`PowerProfileType`	`MEDIUM_THROUGHPUT_INFERENCE`	`POWER_PROFILE_MEDIUM_THROUGHPUT_INFERENCE`
`nvml`	`PowerProfileType`	`MEMORY_BOUND`	`POWER_PROFILE_MEMORY_BOUND`
`nvml`	`PowerProfileType`	`MIG`	`POWER_PROFILE_MIG`
`nvml`	`PowerProfileType`	`NETWORK`	`POWER_PROFILE_NETWORK`
`nvml`	`PowerProfileType`	`NETWORK_BOUND`	`POWER_PROFILE_NETWORK_BOUND`
`nvml`	`PowerProfileType`	`RBM`	`POWER_PROFILE_RBM`
`nvml`	`PowerProfileType`	`SYNC_BALANCED`	`POWER_PROFILE_SYNC_BALANCED`
`nvml`	`PowerProfileType`	`TRAINING`	`POWER_PROFILE_TRAINING`
`nvml`	`TemperatureSensors`	`COUNT`	`TEMPERATURE_COUNT`
`nvml`	`TemperatureSensors`	`GPU`	`TEMPERATURE_GPU`
`nvml`	`TemperatureSensors`	`GPU_MAX`	`TEMPERATURE_GPU_MAX`
`nvml`	`TemperatureThresholds`	`ACOUSTIC_CURR`	`TEMPERATURE_THRESHOLD_ACOUSTIC_CURR`
`nvml`	`TemperatureThresholds`	`ACOUSTIC_MAX`	`TEMPERATURE_THRESHOLD_ACOUSTIC_MAX`
`nvml`	`TemperatureThresholds`	`ACOUSTIC_MIN`	`TEMPERATURE_THRESHOLD_ACOUSTIC_MIN`
`nvml`	`TemperatureThresholds`	`COUNT`	`TEMPERATURE_THRESHOLD_COUNT`
`nvml`	`TemperatureThresholds`	`GPS_CURR`	`TEMPERATURE_THRESHOLD_GPS_CURR`
`nvml`	`TemperatureThresholds`	`GPU_MAX`	`TEMPERATURE_THRESHOLD_GPU_MAX`
`nvml`	`TemperatureThresholds`	`MEM_MAX`	`TEMPERATURE_THRESHOLD_MEM_MAX`
`nvml`	`TemperatureThresholds`	`SHUTDOWN`	`TEMPERATURE_THRESHOLD_SHUTDOWN`
`nvml`	`TemperatureThresholds`	`SLOWDOWN`	`TEMPERATURE_THRESHOLD_SLOWDOWN`
`nvml`	`VgpuCapability`	`COUNT`	`VGPU_CAP_COUNT`
`nvml`	`VgpuCapability`	`EXCLUSIVE_SIZE`	`VGPU_CAP_EXCLUSIVE_SIZE`
`nvml`	`VgpuCapability`	`EXCLUSIVE_TYPE`	`VGPU_CAP_EXCLUSIVE_TYPE`
`nvml`	`VgpuCapability`	`GPUDIRECT`	`VGPU_CAP_GPUDIRECT`
`nvml`	`VgpuCapability`	`MULTI_VGPU_EXCLUSIVE`	`VGPU_CAP_MULTI_VGPU_EXCLUSIVE`
`nvml`	`VgpuCapability`	`NVLINK_P2P`	`VGPU_CAP_NVLINK_P2P`
`nvml`	`VgpuDriverCapability`	`COUNT`	`VGPU_DRIVER_CAP_COUNT`
`nvml`	`VgpuDriverCapability`	`HETEROGENEOUS_MULTI_VGPU`	`VGPU_DRIVER_CAP_HETEROGENEOUS_MULTI_VGPU`
`nvml`	`VgpuDriverCapability`	`WARM_UPDATE`	`VGPU_DRIVER_CAP_WARM_UPDATE`
`nvml`	`VgpuGuestInfoState`	`INITIALIZED`	`VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED`
`nvml`	`VgpuGuestInfoState`	`UNINITIALIZED`	`VGPU_INSTANCE_GUEST_INFO_STATE_UNINITIALIZED`
`nvml`	`VgpuPgpuCompatibilityLimitCode`	`GPU`	`VGPU_COMPATIBILITY_LIMIT_GPU`
`nvml`	`VgpuPgpuCompatibilityLimitCode`	`GUEST_DRIVER`	`VGPU_COMPATIBILITY_LIMIT_GUEST_DRIVER`
`nvml`	`VgpuPgpuCompatibilityLimitCode`	`HOST_DRIVER`	`VGPU_COMPATIBILITY_LIMIT_HOST_DRIVER`
`nvml`	`VgpuPgpuCompatibilityLimitCode`	`NONE`	`VGPU_COMPATIBILITY_LIMIT_NONE`
`nvml`	`VgpuPgpuCompatibilityLimitCode`	`OTHER`	`VGPU_COMPATIBILITY_LIMIT_OTHER`
`nvml`	`VgpuVmIdType`	`DOMAIN_ID`	`VGPU_VM_ID_DOMAIN_ID`
`nvml`	`VgpuVmIdType`	`UUID`	`VGPU_VM_ID_UUID`

nvml.device_get_samples: On a zero-sample result, the old implementation
returned a bare Sample instance instead of the documented
(sample_val_type, samples) tuple. It now always returns the correct 2-tuple.
nvml.device_get_supported_vgpus, nvml.device_get_creatable_vgpus,
nvml.device_get_active_vgpus: The old implementations would return a
NameError at runtime whenever there was at least one result to return. Now
fixed.
nvml.device_get_gpu_instances,
nvml.gpu_instance_get_compute_instances: The old implementations would fail
with ValueError: Invalid shape in axis 0: 0 whenever the result is empty.
Now correctly returns an empty array in that case.
nvml.device_get_vgpu_utilization: The old implementation would only fill
in the first element of the returned array; the rest was uninitialized
garbage. It is now correctly returned as a properly-sized array. In addition,
the first element of the returned tuple, sample_val_type, is now a plain
int rather than a length-1 array, since it is a single output parameter,
not a per-sample value.
nvml.device_get_vgpu_process_utilization: The old implementation returned
a tuple (sample_count, samples), and the samples array only ever
contained one element. It is now correctly returned as a properly-sized array
(and the redundant sample_count — which was only ever the array's own size —
is no longer part of the returned value; use len(result) instead).
nvml.NvlinkFirmwareInfo: The firmware_version member now returns only
valid entries. The num_valid_entries member is removed, as its design made
it possible to access invalid memory.

Enhancements

cuda-bindings docstrings now include the full documentation from the upstream CTK, not just the first paragraph.
The following functions now accept None for their buffer-like pointer argument (an integer address or an object supporting the buffer protocol), which is treated as NULL.
- cudla.module_load_from_memory (p_module)
- cudla.submit_task (ptr_to_tasks)
- cufile.handle_register (descr)
- cufile.batch_io_submit, cufile.batch_io_get_status (iocbp)
- cufile.get_stats_l1, cufile.get_stats_l2, cufile.get_stats_l3 (stats)
- nvfatbin.add_cubin, nvfatbin.add_index, nvfatbin.add_ltoir, nvfatbin.add_ptx, nvfatbin.add_reloc, nvfatbin.add_tile_ir (code)
- nvfatbin.get (buffer)
- nvjitlink.add_data (data)
- nvjitlink.get_error_log, nvjitlink.get_info_log (log)
- nvjitlink.get_linked_cubin (cubin)
- nvjitlink.get_linked_ltoir (ltoir)
- nvjitlink.get_linked_ptx (ptx)
- nvml.device_set_clock_offsets (info)
- nvml.device_set_nvlink_bw_mode (set_bw_mode)
- nvml.device_modify_drain_state, nvml.device_query_drain_state, nvml.device_remove_gpu_v2, nvml.device_discover_gpus (pci_info)
- nvml.gpu_instance_set_vgpu_scheduler_state (p_scheduler)
- nvml.set_vgpu_version (vgpu_version)
- nvml.device_create_gpu_instance_with_placement, nvml.gpu_instance_create_compute_instance_with_placement (placement)
- nvml.device_set_power_mizer_mode_v1 (power_mizer_mode)
- nvml.device_set_vgpu_scheduler_state_v2, nvml.gpu_instance_set_vgpu_scheduler_state_v2 (p_scheduler_state)
- nvml.device_set_memory_limits_v1 (limits)
- nvml.event_set_register_gpu_operational_events_v1 (config)
- nvvm.add_module_to_program, nvvm.lazy_add_module_to_program, nvvm.get_compiled_result, nvvm.get_program_log (buffer)
Buffer-like pointer arguments in cudla, nvfatbin, nvjitlink and nvvm are no longer required to be 1D. Any contiguous buffer
(a ctypes object, NumPy array of any shape, bytes, ...) is accepted, and the error message for an invalid buffer says so.
For all cuda-bindings APIs, functions that accept a struct wrapper will accept the struct wrapper directly, rather than requiring getting the .ptr property.
Creating class instances in cuda-bindings should now be faster in most cases, because it requires 1 heap allocation rather than 2.
Before a source build compiles anything, it now checks that the CUDA Toolkit's cuda.h has the major.minor the source tree was generated from. A mismatch stops the build with a message that names the header found and the version needed. Previously a mismatch surfaced as a long list of C++ redefinition errors.
Wrappers of arrays of CUDA structs are now 5x - 30x faster for most common operations (thanks to a contribution from Yang Gao). This affects cufile, nvml and _v2.driver.

Behavior changes

Passing a None to nvvm.add_module_to_program or nvvm.lazy_add_module_to_program will now raise a nvvm.nvvmError (INVALID_INPUT) rather than a ValueError.

Deprecations

Two cuda.bindings.nvml exception classes were renamed so that they no longer have the same name as a Python builtin
exception. Code that did from cuda.bindings.nvml import * (or from cuda.bindings.nvml import TimeoutError)
replaced the builtin TimeoutError and MemoryError in its namespace. Update code that refers to the old names:
- nvml.TimeoutError is now nvml.NvmlTimeoutError.
- nvml.MemoryError is now nvml.NvmlMemoryError.
They are still subclasses of nvml.NvmlError, and the error codes they represent
(ERROR_TIMEOUT and ERROR_MEMORY) are unchanged, so except nvml.NvmlError is not affected.

Bugfixes

A number of incorrect docstrings have been corrected.
Setting a cuda_bindings class instance to itself (obj = cuda_bindings.driver.Class(); obj[0] = obj) will no longer crash or use garbage values.
Fix a potential use-after-free error in the destructors of classes in driver and runtime.
driver.cuLaunchHostFunc and runtime.cudaLaunchHostFunc now pass the host
function and its user data to CUDA unchanged. They used to route the call through
an internal trampoline that freed its state after the first invocation, so a host
function captured into a CUDA graph crashed on the second launch of that graph.
(Issue #790)
Callers must retain the callback object and user data storage for the lifetime
of the graph and its executables, including pending launches; see
{ref}host-function-lifetime.
cufile and nvml struct array wrappers (for example nvml.ProcessInfo and cufile.IOParams) are now zero-initialized when
created with a given size. Previously they were allocated with uninitialized memory, so unset fields held garbage values.
Assigning to a member of a read-only cufile or nvml struct array wrapper now raises ValueError ("This instance is
read-only"). Previously no such check was made.
Fix a crash when registering or unregistering callbacks (cuLogs* and the *AsyncNotification functions)
concurrently from multiple threads under free-threaded Python.
(Issue #3282)
nvml field-value queries (e.g. nvml.device_get_field_values) no longer return results from unpopulated queries as if they were valid;
per-query error status is now initialized before the call.
nvml.PwrModelMetricsPfpp1x and nvml.PwrModelMetricsDlppm1x array wrappers now populate their nested estimated_metrics member
with one array per element, sized by num_vf_points and num_estimated_metrics respectively.

Preview feature

A new version of the nvrtc and driver APIs is available as
cuda.bindings._v2.nvrtc and cuda.bindings._v2.driver. The primary
improvements are: (1) raising exceptions rather than returning error codes, (2)
uses PEP8-compliant naming, and (3) more performance. This API is still
experimental and subject to change.

See the {ref}v2 migration guide <v2-migration> for details on migrating to new API.

Known issues

When using cuda-bindings with cufile 13.4.x, cuda.bindings.cufile.get_stats_l1 and cuda.bindings.cufile.get_stats_l2 may segfault.
See issue #2794.
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.
nvml.system_get_process_name on WSL can return incorrect values. To work around this, set the locale to "C" before calling nvml.device_get_compute_running_processes_v3 (which sets the process names) and before calling nvml.system_get_process_name. cuda_core does this automatically, but users of the raw NVML API will need to do this manually.

Navigation Menu

Repository navigation

Release v13.5.0

Choose a tag to compare

Sorry, something went wrong.