Merge branch 'main' into abhilash1910→nvvm_enhance

Author: rwgk

.git_archival.txt

@@ -0,0 +1,3 @@
+node: $Format:%H$
+node-date: $Format:%cI$
+ref-names: $Format:%D$

.gitattributes

@@ -1,5 +1,3 @@
-cuda/_version.py export-subst
-
 * text eol=lf
 *.cmd text eol=crlf
 
@@ -16,3 +14,9 @@ cuda_core/cuda/core/_cpp/*.hpp -binary text diff
 *.svg binary
 # SCM syntax highlighting & preventing 3-way merges
 pixi.lock merge=binary linguist-language=YAML linguist-generated=true
+
+# "export-subst" specifies that this file will get filled in with the current
+# commit and tag information when running `git archive`.  This allows
+# `setuptools-scm` to correctly determine the version when building from a git
+# archive.  See #1609.
+.git_archival.txt export-subst

.pre-commit-config.yaml

@@ -29,7 +29,7 @@ repos:
         language: python
         additional_dependencies:
           - https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl
-        exclude: '.*pixi\.lock'
+        exclude: '(.*pixi\.lock)|(\.git_archival\.txt)'
         args: ["--fix"]
 
       - id: no-markdown-in-docs-source

ci/tools/run-tests

@@ -34,8 +34,9 @@ if [[ "${test_module}" == "pathfinder" ]]; then
     "FH:${CUDA_PATHFINDER_TEST_FIND_NVIDIA_HEADERS_STRICTNESS} " \
     "BC:${CUDA_PATHFINDER_TEST_FIND_NVIDIA_BITCODE_LIB_STRICTNESS}"
   pytest -ra -s -v --durations=0 tests/ |& tee /tmp/pathfinder_test_log.txt
-  # Fail if no "INFO test_" lines are found; capture line count otherwise
-  line_count=$(grep '^INFO test_' /tmp/pathfinder_test_log.txt | wc -l)
+  # Report the number of "INFO test_" lines (including zero)
+  # to support quick validations based on GHA log archives.
+  line_count=$(awk '/^INFO test_/ {count++} END {print count+0}' /tmp/pathfinder_test_log.txt)
   echo "Number of \"INFO test_\" lines: $line_count"
   popd
 elif [[ "${test_module}" == "bindings" ]]; then

cuda_bindings/.git_archival.txt

@@ -0,0 +1 @@
+../.git_archival.txt

cuda_bindings/cuda/bindings/_internal/_fast_enum.py

@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+
+# This code was automatically generated across versions from 12.9.1 to 13.1.1. Do not modify it directly.
+
+
+"""
+This is a replacement for the stdlib enum.IntEnum.
+
+Notably, it has much better import time performance, since it doesn't generate
+and evaluate Python code at startup time.
+
+It supports the most important subset of the IntEnum API.  See `test_enum` in
+`cuda_bindings/tests/test_basics.py` for details.
+"""
+
+from typing import Any, Iterator
+
+
+class FastEnumMetaclass(type):
+    def __init__(cls, name, bases, namespace):
+        super().__init__(name, bases, namespace)
+
+        cls.__singletons__ = {}
+        cls.__members__ = {}
+        for name, value in cls.__dict__.items():
+            if name.startswith("__") and name.endswith("__"):
+                continue
+
+            if isinstance(value, tuple):
+                value, doc = value
+            elif isinstance(value, int):
+                doc = None
+            else:
+                continue
+
+            singleton = int.__new__(cls, value)
+            singleton.__doc__ = doc
+            singleton._name = name
+            cls.__singletons__[value] = singleton
+            cls.__members__[name] = singleton
+
+        for name, member in cls.__members__.items():
+            setattr(cls, name, member)
+
+    def __repr__(cls) -> str:
+        return f"<enum '{cls.__name__}'>"
+
+    def __len__(cls) -> int:
+        return len(cls.__members__)
+
+    def __iter__(cls) -> Iterator["FastEnum"]:
+        return iter(cls.__members__.values())
+
+    def __contains__(cls, item: Any) -> bool:
+        return item in cls.__singletons__
+
+
+class FastEnum(int, metaclass=FastEnumMetaclass):
+    def __new__(cls, value: int) -> "FastEnum":
+        singleton: FastEnum = cls.__singletons__.get(value)
+        if singleton is None:
+            raise ValueError(f"{value} is not a valid {cls.__name__}")
+        return singleton
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}.{self._name}: {int(self)}>"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def value(self) -> int:
+        return int(self)

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

@@ -1,12 +1,12 @@
-# SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
 
 from cpython.buffer cimport PyObject_CheckBuffer, PyObject_GetBuffer, PyBuffer_Release, PyBUF_SIMPLE, PyBUF_ANY_CONTIGUOUS
 from libc.stdlib cimport calloc, free
 from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t
 from libc.stddef cimport wchar_t
 from libc.string cimport memcpy
-from enum import Enum as _Enum
+from cuda.bindings._internal._fast_enum import FastEnum as _FastEnum
 import ctypes as _ctypes
 cimport cuda.bindings.cydriver as cydriver
 cimport cuda.bindings._lib.param_packer as param_packer
@@ -73,7 +73,7 @@ cdef class _HelperKernelParams:
                         self._ckernelParams[idx] = <void*><void_ptr>value.getPtr()
                     elif isinstance(value, (_ctypes.Structure)):
                         self._ckernelParams[idx] = <void*><void_ptr>_ctypes.addressof(value)
-                    elif isinstance(value, (_Enum)):
+                    elif isinstance(value, (_FastEnum)):
                         self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
                         (<int*>self._ckernelParams[idx])[0] = value.value
                         data_idx += sizeof(int)

cuda_bindings/cuda/bindings/cufile.pyx

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 #
 # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
 #
@@ -8,7 +8,7 @@ cimport cython  # NOQA
 from libc cimport errno
 from ._internal.utils cimport (get_buffer_pointer, get_nested_resource_ptr,
                                nested_resource)
-from enum import IntEnum as _IntEnum
+from cuda.bindings._internal._fast_enum import FastEnum as _FastEnum
 
 import cython
 
@@ -2288,6 +2288,8 @@ cdef class StatsLevel2:
     def read_size_kb_hist(self, val):
         if self._readonly:
             raise ValueError("This StatsLevel2 instance is read-only")
+        if len(val) != 32:
+            raise ValueError(f"Expected length { 32 } for field read_size_kb_hist, got {len(val)}")
         cdef view.array arr = view.array(shape=(32,), itemsize=sizeof(uint64_t), format="Q", mode="c")
         arr[:] = _numpy.asarray(val, dtype=_numpy.uint64)
         memcpy(<void *>(&(self._ptr[0].read_size_kb_hist)), <void *>(arr.data), sizeof(uint64_t) * len(val))
@@ -2303,6 +2305,8 @@ cdef class StatsLevel2:
     def write_size_kb_hist(self, val):
         if self._readonly:
             raise ValueError("This StatsLevel2 instance is read-only")
+        if len(val) != 32:
+            raise ValueError(f"Expected length { 32 } for field write_size_kb_hist, got {len(val)}")
         cdef view.array arr = view.array(shape=(32,), itemsize=sizeof(uint64_t), format="Q", mode="c")
         arr[:] = _numpy.asarray(val, dtype=_numpy.uint64)
         memcpy(<void *>(&(self._ptr[0].write_size_kb_hist)), <void *>(arr.data), sizeof(uint64_t) * len(val))
@@ -2441,7 +2445,7 @@ cdef class StatsLevel3:
             raise ValueError("This StatsLevel3 instance is read-only")
         cdef PerGpuStats val_ = val
         if len(val) != 16:
-            raise ValueError(f"Expected length 16 for field per_gpu_stats, got {len(val)}")
+            raise ValueError(f"Expected length { 16 } for field per_gpu_stats, got {len(val)}")
         memcpy(<void *>&(self._ptr[0].per_gpu_stats), <void *>(val_._get_ptr()), sizeof(CUfilePerGpuStats_t) * 16)
 
     @property
@@ -2496,8 +2500,10 @@ cdef class StatsLevel3:
 # Enum
 ###############################################################################
 
-class OpError(_IntEnum):
-    """See `CUfileOpError`."""
+class OpError(_FastEnum):
+    """
+    See `CUfileOpError`.
+    """
     SUCCESS = CU_FILE_SUCCESS
     DRIVER_NOT_INITIALIZED = CU_FILE_DRIVER_NOT_INITIALIZED
     DRIVER_INVALID_PROPS = CU_FILE_DRIVER_INVALID_PROPS
@@ -2548,49 +2554,61 @@ class OpError(_IntEnum):
     BATCH_NOCOMPAT_ERROR = CU_FILE_BATCH_NOCOMPAT_ERROR
     IO_MAX_ERROR = CU_FILE_IO_MAX_ERROR
 
-class DriverStatusFlags(_IntEnum):
-    """See `CUfileDriverStatusFlags_t`."""
-    LUSTRE_SUPPORTED = CU_FILE_LUSTRE_SUPPORTED
-    WEKAFS_SUPPORTED = CU_FILE_WEKAFS_SUPPORTED
-    NFS_SUPPORTED = CU_FILE_NFS_SUPPORTED
+class DriverStatusFlags(_FastEnum):
+    """
+    See `CUfileDriverStatusFlags_t`.
+    """
+    LUSTRE_SUPPORTED = (CU_FILE_LUSTRE_SUPPORTED, 'Support for DDN LUSTRE')
+    WEKAFS_SUPPORTED = (CU_FILE_WEKAFS_SUPPORTED, 'Support for WEKAFS')
+    NFS_SUPPORTED = (CU_FILE_NFS_SUPPORTED, 'Support for NFS')
     GPFS_SUPPORTED = CU_FILE_GPFS_SUPPORTED
-    NVME_SUPPORTED = CU_FILE_NVME_SUPPORTED
-    NVMEOF_SUPPORTED = CU_FILE_NVMEOF_SUPPORTED
-    SCSI_SUPPORTED = CU_FILE_SCSI_SUPPORTED
-    SCALEFLUX_CSD_SUPPORTED = CU_FILE_SCALEFLUX_CSD_SUPPORTED
-    NVMESH_SUPPORTED = CU_FILE_NVMESH_SUPPORTED
-    BEEGFS_SUPPORTED = CU_FILE_BEEGFS_SUPPORTED
-    NVME_P2P_SUPPORTED = CU_FILE_NVME_P2P_SUPPORTED
-    SCATEFS_SUPPORTED = CU_FILE_SCATEFS_SUPPORTED
-    VIRTIOFS_SUPPORTED = CU_FILE_VIRTIOFS_SUPPORTED
-    MAX_TARGET_TYPES = CU_FILE_MAX_TARGET_TYPES
-
-class DriverControlFlags(_IntEnum):
-    """See `CUfileDriverControlFlags_t`."""
-    USE_POLL_MODE = CU_FILE_USE_POLL_MODE
-    ALLOW_COMPAT_MODE = CU_FILE_ALLOW_COMPAT_MODE
-
-class FeatureFlags(_IntEnum):
-    """See `CUfileFeatureFlags_t`."""
-    DYN_ROUTING_SUPPORTED = CU_FILE_DYN_ROUTING_SUPPORTED
-    BATCH_IO_SUPPORTED = CU_FILE_BATCH_IO_SUPPORTED
-    STREAMS_SUPPORTED = CU_FILE_STREAMS_SUPPORTED
-    PARALLEL_IO_SUPPORTED = CU_FILE_PARALLEL_IO_SUPPORTED
-    P2P_SUPPORTED = CU_FILE_P2P_SUPPORTED
-
-class FileHandleType(_IntEnum):
-    """See `CUfileFileHandleType`."""
-    OPAQUE_FD = CU_FILE_HANDLE_TYPE_OPAQUE_FD
-    OPAQUE_WIN32 = CU_FILE_HANDLE_TYPE_OPAQUE_WIN32
+    NVME_SUPPORTED = (CU_FILE_NVME_SUPPORTED, '< Support for GPFS Support for NVMe')
+    NVMEOF_SUPPORTED = (CU_FILE_NVMEOF_SUPPORTED, 'Support for NVMeOF')
+    SCSI_SUPPORTED = (CU_FILE_SCSI_SUPPORTED, 'Support for SCSI')
+    SCALEFLUX_CSD_SUPPORTED = (CU_FILE_SCALEFLUX_CSD_SUPPORTED, 'Support for Scaleflux CSD')
+    NVMESH_SUPPORTED = (CU_FILE_NVMESH_SUPPORTED, 'Support for NVMesh Block Dev')
+    BEEGFS_SUPPORTED = (CU_FILE_BEEGFS_SUPPORTED, 'Support for BeeGFS')
+    NVME_P2P_SUPPORTED = (CU_FILE_NVME_P2P_SUPPORTED, 'Do not use this macro. This is deprecated now')
+    SCATEFS_SUPPORTED = (CU_FILE_SCATEFS_SUPPORTED, 'Support for ScateFS')
+    VIRTIOFS_SUPPORTED = (CU_FILE_VIRTIOFS_SUPPORTED, 'Support for VirtioFS')
+    MAX_TARGET_TYPES = (CU_FILE_MAX_TARGET_TYPES, 'Maximum FS supported')
+
+class DriverControlFlags(_FastEnum):
+    """
+    See `CUfileDriverControlFlags_t`.
+    """
+    USE_POLL_MODE = (CU_FILE_USE_POLL_MODE, 'use POLL mode. properties.use_poll_mode')
+    ALLOW_COMPAT_MODE = (CU_FILE_ALLOW_COMPAT_MODE, 'allow COMPATIBILITY mode. properties.allow_compat_mode')
+
+class FeatureFlags(_FastEnum):
+    """
+    See `CUfileFeatureFlags_t`.
+    """
+    DYN_ROUTING_SUPPORTED = (CU_FILE_DYN_ROUTING_SUPPORTED, 'Support for Dynamic routing to handle devices across the PCIe bridges')
+    BATCH_IO_SUPPORTED = (CU_FILE_BATCH_IO_SUPPORTED, 'Supported')
+    STREAMS_SUPPORTED = (CU_FILE_STREAMS_SUPPORTED, 'Supported')
+    PARALLEL_IO_SUPPORTED = (CU_FILE_PARALLEL_IO_SUPPORTED, 'Supported')
+    P2P_SUPPORTED = (CU_FILE_P2P_SUPPORTED, 'Support for PCI P2PDMA')
+
+class FileHandleType(_FastEnum):
+    """
+    See `CUfileFileHandleType`.
+    """
+    OPAQUE_FD = (CU_FILE_HANDLE_TYPE_OPAQUE_FD, 'Linux based fd')
+    OPAQUE_WIN32 = (CU_FILE_HANDLE_TYPE_OPAQUE_WIN32, 'Windows based handle (unsupported)')
     USERSPACE_FS = CU_FILE_HANDLE_TYPE_USERSPACE_FS
 
-class Opcode(_IntEnum):
-    """See `CUfileOpcode_t`."""
+class Opcode(_FastEnum):
+    """
+    See `CUfileOpcode_t`.
+    """
     READ = CUFILE_READ
     WRITE = CUFILE_WRITE
 
-class Status(_IntEnum):
-    """See `CUfileStatus_t`."""
+class Status(_FastEnum):
+    """
+    See `CUfileStatus_t`.
+    """
     WAITING = CUFILE_WAITING
     PENDING = CUFILE_PENDING
     INVALID = CUFILE_INVALID
@@ -2599,12 +2617,16 @@ class Status(_IntEnum):
     TIMEOUT = CUFILE_TIMEOUT
     FAILED = CUFILE_FAILED
 
-class BatchMode(_IntEnum):
-    """See `CUfileBatchMode_t`."""
+class BatchMode(_FastEnum):
+    """
+    See `CUfileBatchMode_t`.
+    """
     BATCH = CUFILE_BATCH
 
-class SizeTConfigParameter(_IntEnum):
-    """See `CUFileSizeTConfigParameter_t`."""
+class SizeTConfigParameter(_FastEnum):
+    """
+    See `CUFileSizeTConfigParameter_t`.
+    """
     PROFILE_STATS = CUFILE_PARAM_PROFILE_STATS
     EXECUTION_MAX_IO_QUEUE_DEPTH = CUFILE_PARAM_EXECUTION_MAX_IO_QUEUE_DEPTH
     EXECUTION_MAX_IO_THREADS = CUFILE_PARAM_EXECUTION_MAX_IO_THREADS
@@ -2618,8 +2640,10 @@ class SizeTConfigParameter(_IntEnum):
     POLLTHRESHOLD_SIZE_KB = CUFILE_PARAM_POLLTHRESHOLD_SIZE_KB
     PROPERTIES_BATCH_IO_TIMEOUT_MS = CUFILE_PARAM_PROPERTIES_BATCH_IO_TIMEOUT_MS
 
-class BoolConfigParameter(_IntEnum):
-    """See `CUFileBoolConfigParameter_t`."""
+class BoolConfigParameter(_FastEnum):
+    """
+    See `CUFileBoolConfigParameter_t`.
+    """
     PROPERTIES_USE_POLL_MODE = CUFILE_PARAM_PROPERTIES_USE_POLL_MODE
     PROPERTIES_ALLOW_COMPAT_MODE = CUFILE_PARAM_PROPERTIES_ALLOW_COMPAT_MODE
     FORCE_COMPAT_MODE = CUFILE_PARAM_FORCE_COMPAT_MODE
@@ -2633,24 +2657,30 @@ class BoolConfigParameter(_IntEnum):
     SKIP_TOPOLOGY_DETECTION = CUFILE_PARAM_SKIP_TOPOLOGY_DETECTION
     STREAM_MEMOPS_BYPASS = CUFILE_PARAM_STREAM_MEMOPS_BYPASS
 
-class StringConfigParameter(_IntEnum):
-    """See `CUFileStringConfigParameter_t`."""
+class StringConfigParameter(_FastEnum):
+    """
+    See `CUFileStringConfigParameter_t`.
+    """
     LOGGING_LEVEL = CUFILE_PARAM_LOGGING_LEVEL
     ENV_LOGFILE_PATH = CUFILE_PARAM_ENV_LOGFILE_PATH
     LOG_DIR = CUFILE_PARAM_LOG_DIR
 
-class ArrayConfigParameter(_IntEnum):
-    """See `CUFileArrayConfigParameter_t`."""
+class ArrayConfigParameter(_FastEnum):
+    """
+    See `CUFileArrayConfigParameter_t`.
+    """
     POSIX_POOL_SLAB_SIZE_KB = CUFILE_PARAM_POSIX_POOL_SLAB_SIZE_KB
     POSIX_POOL_SLAB_COUNT = CUFILE_PARAM_POSIX_POOL_SLAB_COUNT
 
-class P2PFlags(_IntEnum):
-    """See `CUfileP2PFlags_t`."""
-    P2PDMA = CUFILE_P2PDMA
-    NVFS = CUFILE_NVFS
-    DMABUF = CUFILE_DMABUF
-    C2C = CUFILE_C2C
-    NVIDIA_PEERMEM = CUFILE_NVIDIA_PEERMEM
+class P2PFlags(_FastEnum):
+    """
+    See `CUfileP2PFlags_t`.
+    """
+    P2PDMA = (CUFILE_P2PDMA, 'Support for PCI P2PDMA')
+    NVFS = (CUFILE_NVFS, 'Support for nvidia-fs')
+    DMABUF = (CUFILE_DMABUF, 'Support for DMA Buffer')
+    C2C = (CUFILE_C2C, 'Support for Chip-to-Chip (Grace-based systems)')
+    NVIDIA_PEERMEM = (CUFILE_NVIDIA_PEERMEM, 'Only for IBM Spectrum Scale and WekaFS')
 
 
 ###############################################################################