Add files using upload-large-folder tool

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+from cuda.bindings import utils
+from cuda.bindings._version import __version__

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/_version.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+__version__ = "12.9.4"

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cufile.pxd

@@ -0,0 +1,73 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.9.0 to 12.9.1. Do not modify it directly.
+
+from libc.stdint cimport intptr_t
+
+from .cycufile cimport *
+
+
+###############################################################################
+# Types
+###############################################################################
+
+ctypedef CUfileHandle_t Handle
+ctypedef CUfileBatchHandle_t BatchHandle
+ctypedef CUfileError_t Error
+ctypedef cufileRDMAInfo_t RDMAInfo
+ctypedef CUfileFSOps_t FSOps
+ctypedef CUfileDrvProps_t DrvProps
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+ctypedef CUfileOpError _OpError
+ctypedef CUfileDriverStatusFlags_t _DriverStatusFlags
+ctypedef CUfileDriverControlFlags_t _DriverControlFlags
+ctypedef CUfileFeatureFlags_t _FeatureFlags
+ctypedef CUfileFileHandleType _FileHandleType
+ctypedef CUfileOpcode_t _Opcode
+ctypedef CUfileStatus_t _Status
+ctypedef CUfileBatchMode_t _BatchMode
+ctypedef CUFileSizeTConfigParameter_t _SizeTConfigParameter
+ctypedef CUFileBoolConfigParameter_t _BoolConfigParameter
+ctypedef CUFileStringConfigParameter_t _StringConfigParameter
+
+
+###############################################################################
+# Functions
+###############################################################################
+
+cpdef intptr_t handle_register(intptr_t descr) except? 0
+cpdef void handle_deregister(intptr_t fh) except*
+cpdef buf_register(intptr_t buf_ptr_base, size_t length, int flags)
+cpdef buf_deregister(intptr_t buf_ptr_base)
+cpdef read(intptr_t fh, intptr_t buf_ptr_base, size_t size, off_t file_offset, off_t buf_ptr_offset)
+cpdef write(intptr_t fh, intptr_t buf_ptr_base, size_t size, off_t file_offset, off_t buf_ptr_offset)
+cpdef driver_open()
+cpdef use_count()
+cpdef driver_get_properties(intptr_t props)
+cpdef driver_set_poll_mode(bint poll, size_t poll_threshold_size)
+cpdef driver_set_max_direct_io_size(size_t max_direct_io_size)
+cpdef driver_set_max_cache_size(size_t max_cache_size)
+cpdef driver_set_max_pinned_mem_size(size_t max_pinned_size)
+cpdef intptr_t batch_io_set_up(unsigned nr) except? 0
+cpdef batch_io_submit(intptr_t batch_idp, unsigned nr, intptr_t iocbp, unsigned int flags)
+cpdef batch_io_get_status(intptr_t batch_idp, unsigned min_nr, intptr_t nr, intptr_t iocbp, intptr_t timeout)
+cpdef batch_io_cancel(intptr_t batch_idp)
+cpdef void batch_io_destroy(intptr_t batch_idp) except*
+cpdef read_async(intptr_t fh, intptr_t buf_ptr_base, intptr_t size_p, intptr_t file_offset_p, intptr_t buf_ptr_offset_p, intptr_t bytes_read_p, intptr_t stream)
+cpdef write_async(intptr_t fh, intptr_t buf_ptr_base, intptr_t size_p, intptr_t file_offset_p, intptr_t buf_ptr_offset_p, intptr_t bytes_written_p, intptr_t stream)
+cpdef stream_register(intptr_t stream, unsigned flags)
+cpdef stream_deregister(intptr_t stream)
+cpdef int get_version() except? 0
+cpdef size_t get_parameter_size_t(int param) except? 0
+cpdef bint get_parameter_bool(int param) except? 0
+cpdef str get_parameter_string(int param, int len)
+cpdef set_parameter_size_t(int param, size_t value)
+cpdef set_parameter_bool(int param, bint value)
+cpdef set_parameter_string(int param, intptr_t desc_str)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cufile.pyx

@@ -0,0 +1,1296 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.9.0 to 12.9.1. Do not modify it directly.
+
+cimport cython  # NOQA
+from libc cimport errno
+from ._internal.utils cimport (get_buffer_pointer, get_nested_resource_ptr,
+                               nested_resource)
+import numpy as _numpy
+from cpython cimport buffer as _buffer
+from cpython.memoryview cimport PyMemoryView_FromMemory
+from enum import IntEnum as _IntEnum
+
+import cython
+
+from cuda.bindings.driver import CUresult as pyCUresult
+
+
+###############################################################################
+# POD
+###############################################################################
+
+_py_anon_pod1_dtype = _numpy.dtype((
+    _numpy.dtype((_numpy.void, sizeof((<CUfileDescr_t*>NULL).handle))),
+    {
+        "fd": (_numpy.int32, 0),
+        "handle": (_numpy.intp, 0),
+    }
+    ))
+
+
+cdef class _py_anon_pod1:
+    """Empty-initialize an instance of `_anon_pod1`.
+
+
+    .. seealso:: `_anon_pod1`
+    """
+    cdef:
+        readonly object _data
+
+    def __init__(self):
+        arr = _numpy.empty(1, dtype=_py_anon_pod1_dtype)
+        self._data = arr.view(_numpy.recarray)
+        assert self._data.itemsize == sizeof((<CUfileDescr_t*>NULL).handle), \
+            f"itemsize {self._data.itemsize} mismatches union size {sizeof((<CUfileDescr_t*>NULL).handle)}"
+
+    def __repr__(self):
+        return f"<{__name__}._py_anon_pod1 object at {hex(id(self))}>"
+
+    @property
+    def ptr(self):
+        """Get the pointer address to the data as Python :class:`int`."""
+        return self._data.ctypes.data
+
+    def __int__(self):
+        return self._data.ctypes.data
+
+    def __eq__(self, other):
+        if not isinstance(other, _py_anon_pod1):
+            return False
+        if self._data.size != other._data.size:
+            return False
+        if self._data.dtype != other._data.dtype:
+            return False
+        return bool((self._data == other._data).all())
+
+    @property
+    def fd(self):
+        """int: """
+        return int(self._data.fd[0])
+
+    @fd.setter
+    def fd(self, val):
+        self._data.fd = val
+
+    @property
+    def handle(self):
+        """int: """
+        return int(self._data.handle[0])
+
+    @handle.setter
+    def handle(self, val):
+        self._data.handle = val
+
+    def __setitem__(self, key, val):
+        self._data[key] = val
+
+    @staticmethod
+    def from_data(data):
+        """Create an _py_anon_pod1 instance wrapping the given NumPy array.
+
+        Args:
+            data (_numpy.ndarray): a 1D array of dtype `_py_anon_pod1_dtype` holding the data.
+        """
+        cdef _py_anon_pod1 obj = _py_anon_pod1.__new__(_py_anon_pod1)
+        if not isinstance(data, (_numpy.ndarray, _numpy.recarray)):
+            raise TypeError("data argument must be a NumPy ndarray")
+        if data.ndim != 1:
+            raise ValueError("data array must be 1D")
+        if data.dtype != _py_anon_pod1_dtype:
+            raise ValueError("data array must be of dtype _py_anon_pod1_dtype")
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+    @staticmethod
+    def from_ptr(intptr_t ptr, bint readonly=False):
+        """Create an _py_anon_pod1 instance wrapping the given pointer.
+
+        Args:
+            ptr (intptr_t): pointer address as Python :class:`int` to the data.
+            readonly (bool): whether the data is read-only (to the user). default is `False`.
+        """
+        if ptr == 0:
+            raise ValueError("ptr must not be null (0)")
+        cdef _py_anon_pod1 obj = _py_anon_pod1.__new__(_py_anon_pod1)
+        cdef flag = _buffer.PyBUF_READ if readonly else _buffer.PyBUF_WRITE
+        cdef object buf = PyMemoryView_FromMemory(
+            <char*>ptr, sizeof((<CUfileDescr_t*>NULL).handle), flag)
+        data = _numpy.ndarray((1,), buffer=buf,
+                              dtype=_py_anon_pod1_dtype)
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+
+_py_anon_pod3_dtype = _numpy.dtype([
+    ("dev_ptr_base", _numpy.intp, ),
+    ("file_offset", _numpy.int64, ),
+    ("dev_ptr_offset", _numpy.int64, ),
+    ("size_", _numpy.uint64, ),
+    ], align=True)
+
+
+cdef class _py_anon_pod3:
+    """Empty-initialize an instance of `_anon_pod3`.
+
+
+    .. seealso:: `_anon_pod3`
+    """
+    cdef:
+        readonly object _data
+
+    def __init__(self):
+        arr = _numpy.empty(1, dtype=_py_anon_pod3_dtype)
+        self._data = arr.view(_numpy.recarray)
+        assert self._data.itemsize == sizeof((<CUfileIOParams_t*>NULL).u.batch), \
+            f"itemsize {self._data.itemsize} mismatches struct size {sizeof((<CUfileIOParams_t*>NULL).u.batch)}"
+
+    def __repr__(self):
+        return f"<{__name__}._py_anon_pod3 object at {hex(id(self))}>"
+
+    @property
+    def ptr(self):
+        """Get the pointer address to the data as Python :class:`int`."""
+        return self._data.ctypes.data
+
+    def __int__(self):
+        return self._data.ctypes.data
+
+    def __eq__(self, other):
+        if not isinstance(other, _py_anon_pod3):
+            return False
+        if self._data.size != other._data.size:
+            return False
+        if self._data.dtype != other._data.dtype:
+            return False
+        return bool((self._data == other._data).all())
+
+    @property
+    def dev_ptr_base(self):
+        """int: """
+        return int(self._data.dev_ptr_base[0])
+
+    @dev_ptr_base.setter
+    def dev_ptr_base(self, val):
+        self._data.dev_ptr_base = val
+
+    @property
+    def file_offset(self):
+        """int: """
+        return int(self._data.file_offset[0])
+
+    @file_offset.setter
+    def file_offset(self, val):
+        self._data.file_offset = val
+
+    @property
+    def dev_ptr_offset(self):
+        """int: """
+        return int(self._data.dev_ptr_offset[0])
+
+    @dev_ptr_offset.setter
+    def dev_ptr_offset(self, val):
+        self._data.dev_ptr_offset = val
+
+    @property
+    def size_(self):
+        """int: """
+        return int(self._data.size_[0])
+
+    @size_.setter
+    def size_(self, val):
+        self._data.size_ = val
+
+    def __setitem__(self, key, val):
+        self._data[key] = val
+
+    @staticmethod
+    def from_data(data):
+        """Create an _py_anon_pod3 instance wrapping the given NumPy array.
+
+        Args:
+            data (_numpy.ndarray): a 1D array of dtype `_py_anon_pod3_dtype` holding the data.
+        """
+        cdef _py_anon_pod3 obj = _py_anon_pod3.__new__(_py_anon_pod3)
+        if not isinstance(data, (_numpy.ndarray, _numpy.recarray)):
+            raise TypeError("data argument must be a NumPy ndarray")
+        if data.ndim != 1:
+            raise ValueError("data array must be 1D")
+        if data.dtype != _py_anon_pod3_dtype:
+            raise ValueError("data array must be of dtype _py_anon_pod3_dtype")
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+    @staticmethod
+    def from_ptr(intptr_t ptr, bint readonly=False):
+        """Create an _py_anon_pod3 instance wrapping the given pointer.
+
+        Args:
+            ptr (intptr_t): pointer address as Python :class:`int` to the data.
+            readonly (bool): whether the data is read-only (to the user). default is `False`.
+        """
+        if ptr == 0:
+            raise ValueError("ptr must not be null (0)")
+        cdef _py_anon_pod3 obj = _py_anon_pod3.__new__(_py_anon_pod3)
+        cdef flag = _buffer.PyBUF_READ if readonly else _buffer.PyBUF_WRITE
+        cdef object buf = PyMemoryView_FromMemory(
+            <char*>ptr, sizeof((<CUfileIOParams_t*>NULL).u.batch), flag)
+        data = _numpy.ndarray((1,), buffer=buf,
+                              dtype=_py_anon_pod3_dtype)
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+
+io_events_dtype = _numpy.dtype([
+    ("cookie", _numpy.intp, ),
+    ("status", _numpy.int32, ),
+    ("ret", _numpy.uint64, ),
+    ], align=True)
+
+
+cdef class IOEvents:
+    """Empty-initialize an array of `CUfileIOEvents_t`.
+
+    The resulting object is of length `size` and of dtype `io_events_dtype`.
+    If default-constructed, the instance represents a single struct.
+
+    Args:
+        size (int): number of structs, default=1.
+
+
+    .. seealso:: `CUfileIOEvents_t`
+    """
+    cdef:
+        readonly object _data
+
+    def __init__(self, size=1):
+        arr = _numpy.empty(size, dtype=io_events_dtype)
+        self._data = arr.view(_numpy.recarray)
+        assert self._data.itemsize == sizeof(CUfileIOEvents_t), \
+            f"itemsize {self._data.itemsize} mismatches struct size {sizeof(CUfileIOEvents_t)}"
+
+    def __repr__(self):
+        if self._data.size > 1:
+            return f"<{__name__}.IOEvents_Array_{self._data.size} object at {hex(id(self))}>"
+        else:
+            return f"<{__name__}.IOEvents object at {hex(id(self))}>"
+
+    @property
+    def ptr(self):
+        """Get the pointer address to the data as Python :class:`int`."""
+        return self._data.ctypes.data
+
+    def __int__(self):
+        if self._data.size > 1:
+            raise TypeError("int() argument must be a bytes-like object of size 1. "
+                            "To get the pointer address of an array, use .ptr")
+        return self._data.ctypes.data
+
+    def __len__(self):
+        return self._data.size
+
+    def __eq__(self, other):
+        if not isinstance(other, IOEvents):
+            return False
+        if self._data.size != other._data.size:
+            return False
+        if self._data.dtype != other._data.dtype:
+            return False
+        return bool((self._data == other._data).all())
+
+    @property
+    def cookie(self):
+        """Union[~_numpy.intp, int]: """
+        if self._data.size == 1:
+            return int(self._data.cookie[0])
+        return self._data.cookie
+
+    @cookie.setter
+    def cookie(self, val):
+        self._data.cookie = val
+
+    @property
+    def status(self):
+        """Union[~_numpy.int32, int]: """
+        if self._data.size == 1:
+            return int(self._data.status[0])
+        return self._data.status
+
+    @status.setter
+    def status(self, val):
+        self._data.status = val
+
+    @property
+    def ret(self):
+        """Union[~_numpy.uint64, int]: """
+        if self._data.size == 1:
+            return int(self._data.ret[0])
+        return self._data.ret
+
+    @ret.setter
+    def ret(self, val):
+        self._data.ret = val
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            size = self._data.size
+            if key >= size or key <= -(size+1):
+                raise IndexError("index is out of bounds")
+            if key < 0:
+                key += size
+            return IOEvents.from_data(self._data[key:key+1])
+        out = self._data[key]
+        if isinstance(out, _numpy.recarray) and out.dtype == io_events_dtype:
+            return IOEvents.from_data(out)
+        return out
+
+    def __setitem__(self, key, val):
+        self._data[key] = val
+
+    @staticmethod
+    def from_data(data):
+        """Create an IOEvents instance wrapping the given NumPy array.
+
+        Args:
+            data (_numpy.ndarray): a 1D array of dtype `io_events_dtype` holding the data.
+        """
+        cdef IOEvents obj = IOEvents.__new__(IOEvents)
+        if not isinstance(data, (_numpy.ndarray, _numpy.recarray)):
+            raise TypeError("data argument must be a NumPy ndarray")
+        if data.ndim != 1:
+            raise ValueError("data array must be 1D")
+        if data.dtype != io_events_dtype:
+            raise ValueError("data array must be of dtype io_events_dtype")
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+    @staticmethod
+    def from_ptr(intptr_t ptr, size_t size=1, bint readonly=False):
+        """Create an IOEvents instance wrapping the given pointer.
+
+        Args:
+            ptr (intptr_t): pointer address as Python :class:`int` to the data.
+            size (int): number of structs, default=1.
+            readonly (bool): whether the data is read-only (to the user). default is `False`.
+        """
+        if ptr == 0:
+            raise ValueError("ptr must not be null (0)")
+        cdef IOEvents obj = IOEvents.__new__(IOEvents)
+        cdef flag = _buffer.PyBUF_READ if readonly else _buffer.PyBUF_WRITE
+        cdef object buf = PyMemoryView_FromMemory(
+            <char*>ptr, sizeof(CUfileIOEvents_t) * size, flag)
+        data = _numpy.ndarray((size,), buffer=buf,
+                              dtype=io_events_dtype)
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+
+descr_dtype = _numpy.dtype([
+    ("type", _numpy.int32, ),
+    ("handle", _py_anon_pod1_dtype, ),
+    ("fs_ops", _numpy.intp, ),
+    ], align=True)
+
+
+cdef class Descr:
+    """Empty-initialize an array of `CUfileDescr_t`.
+
+    The resulting object is of length `size` and of dtype `descr_dtype`.
+    If default-constructed, the instance represents a single struct.
+
+    Args:
+        size (int): number of structs, default=1.
+
+
+    .. seealso:: `CUfileDescr_t`
+    """
+    cdef:
+        readonly object _data
+
+    def __init__(self, size=1):
+        arr = _numpy.empty(size, dtype=descr_dtype)
+        self._data = arr.view(_numpy.recarray)
+        assert self._data.itemsize == sizeof(CUfileDescr_t), \
+            f"itemsize {self._data.itemsize} mismatches struct size {sizeof(CUfileDescr_t)}"
+
+    def __repr__(self):
+        if self._data.size > 1:
+            return f"<{__name__}.Descr_Array_{self._data.size} object at {hex(id(self))}>"
+        else:
+            return f"<{__name__}.Descr object at {hex(id(self))}>"
+
+    @property
+    def ptr(self):
+        """Get the pointer address to the data as Python :class:`int`."""
+        return self._data.ctypes.data
+
+    def __int__(self):
+        if self._data.size > 1:
+            raise TypeError("int() argument must be a bytes-like object of size 1. "
+                            "To get the pointer address of an array, use .ptr")
+        return self._data.ctypes.data
+
+    def __len__(self):
+        return self._data.size
+
+    def __eq__(self, other):
+        if not isinstance(other, Descr):
+            return False
+        if self._data.size != other._data.size:
+            return False
+        if self._data.dtype != other._data.dtype:
+            return False
+        return bool((self._data == other._data).all())
+
+    @property
+    def type(self):
+        """Union[~_numpy.int32, int]: """
+        if self._data.size == 1:
+            return int(self._data.type[0])
+        return self._data.type
+
+    @type.setter
+    def type(self, val):
+        self._data.type = val
+
+    @property
+    def handle(self):
+        """_py_anon_pod1_dtype: """
+        return self._data.handle
+
+    @handle.setter
+    def handle(self, val):
+        self._data.handle = val
+
+    @property
+    def fs_ops(self):
+        """Union[~_numpy.intp, int]: """
+        if self._data.size == 1:
+            return int(self._data.fs_ops[0])
+        return self._data.fs_ops
+
+    @fs_ops.setter
+    def fs_ops(self, val):
+        self._data.fs_ops = val
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            size = self._data.size
+            if key >= size or key <= -(size+1):
+                raise IndexError("index is out of bounds")
+            if key < 0:
+                key += size
+            return Descr.from_data(self._data[key:key+1])
+        out = self._data[key]
+        if isinstance(out, _numpy.recarray) and out.dtype == descr_dtype:
+            return Descr.from_data(out)
+        return out
+
+    def __setitem__(self, key, val):
+        self._data[key] = val
+
+    @staticmethod
+    def from_data(data):
+        """Create an Descr instance wrapping the given NumPy array.
+
+        Args:
+            data (_numpy.ndarray): a 1D array of dtype `descr_dtype` holding the data.
+        """
+        cdef Descr obj = Descr.__new__(Descr)
+        if not isinstance(data, (_numpy.ndarray, _numpy.recarray)):
+            raise TypeError("data argument must be a NumPy ndarray")
+        if data.ndim != 1:
+            raise ValueError("data array must be 1D")
+        if data.dtype != descr_dtype:
+            raise ValueError("data array must be of dtype descr_dtype")
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+    @staticmethod
+    def from_ptr(intptr_t ptr, size_t size=1, bint readonly=False):
+        """Create an Descr instance wrapping the given pointer.
+
+        Args:
+            ptr (intptr_t): pointer address as Python :class:`int` to the data.
+            size (int): number of structs, default=1.
+            readonly (bool): whether the data is read-only (to the user). default is `False`.
+        """
+        if ptr == 0:
+            raise ValueError("ptr must not be null (0)")
+        cdef Descr obj = Descr.__new__(Descr)
+        cdef flag = _buffer.PyBUF_READ if readonly else _buffer.PyBUF_WRITE
+        cdef object buf = PyMemoryView_FromMemory(
+            <char*>ptr, sizeof(CUfileDescr_t) * size, flag)
+        data = _numpy.ndarray((size,), buffer=buf,
+                              dtype=descr_dtype)
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+
+_py_anon_pod2_dtype = _numpy.dtype((
+    _numpy.dtype((_numpy.void, sizeof((<CUfileIOParams_t*>NULL).u))),
+    {
+        "batch": (_py_anon_pod3_dtype, 0),
+    }
+    ))
+
+
+cdef class _py_anon_pod2:
+    """Empty-initialize an instance of `_anon_pod2`.
+
+
+    .. seealso:: `_anon_pod2`
+    """
+    cdef:
+        readonly object _data
+
+        readonly object _batch
+
+    def __init__(self):
+        arr = _numpy.empty(1, dtype=_py_anon_pod2_dtype)
+        self._data = arr.view(_numpy.recarray)
+        assert self._data.itemsize == sizeof((<CUfileIOParams_t*>NULL).u), \
+            f"itemsize {self._data.itemsize} mismatches union size {sizeof((<CUfileIOParams_t*>NULL).u)}"
+
+    def __repr__(self):
+        return f"<{__name__}._py_anon_pod2 object at {hex(id(self))}>"
+
+    @property
+    def ptr(self):
+        """Get the pointer address to the data as Python :class:`int`."""
+        return self._data.ctypes.data
+
+    def __int__(self):
+        return self._data.ctypes.data
+
+    def __eq__(self, other):
+        if not isinstance(other, _py_anon_pod2):
+            return False
+        if self._data.size != other._data.size:
+            return False
+        if self._data.dtype != other._data.dtype:
+            return False
+        return bool((self._data == other._data).all())
+
+    @property
+    def batch(self):
+        """_py_anon_pod3: """
+        return self._batch
+
+    def __setitem__(self, key, val):
+        self._data[key] = val
+
+    @staticmethod
+    def from_data(data):
+        """Create an _py_anon_pod2 instance wrapping the given NumPy array.
+
+        Args:
+            data (_numpy.ndarray): a 1D array of dtype `_py_anon_pod2_dtype` holding the data.
+        """
+        cdef _py_anon_pod2 obj = _py_anon_pod2.__new__(_py_anon_pod2)
+        if not isinstance(data, (_numpy.ndarray, _numpy.recarray)):
+            raise TypeError("data argument must be a NumPy ndarray")
+        if data.ndim != 1:
+            raise ValueError("data array must be 1D")
+        if data.dtype != _py_anon_pod2_dtype:
+            raise ValueError("data array must be of dtype _py_anon_pod2_dtype")
+        obj._data = data.view(_numpy.recarray)
+
+        batch_addr = obj._data.batch[0].__array_interface__['data'][0]
+        obj._batch = _py_anon_pod3.from_ptr(batch_addr)
+        return obj
+
+    @staticmethod
+    def from_ptr(intptr_t ptr, bint readonly=False):
+        """Create an _py_anon_pod2 instance wrapping the given pointer.
+
+        Args:
+            ptr (intptr_t): pointer address as Python :class:`int` to the data.
+            readonly (bool): whether the data is read-only (to the user). default is `False`.
+        """
+        if ptr == 0:
+            raise ValueError("ptr must not be null (0)")
+        cdef _py_anon_pod2 obj = _py_anon_pod2.__new__(_py_anon_pod2)
+        cdef flag = _buffer.PyBUF_READ if readonly else _buffer.PyBUF_WRITE
+        cdef object buf = PyMemoryView_FromMemory(
+            <char*>ptr, sizeof((<CUfileIOParams_t*>NULL).u), flag)
+        data = _numpy.ndarray((1,), buffer=buf,
+                              dtype=_py_anon_pod2_dtype)
+        obj._data = data.view(_numpy.recarray)
+
+        batch_addr = obj._data.batch[0].__array_interface__['data'][0]
+        obj._batch = _py_anon_pod3.from_ptr(batch_addr)
+        return obj
+
+
+io_params_dtype = _numpy.dtype([
+    ("mode", _numpy.int32, ),
+    ("u", _py_anon_pod2_dtype, ),
+    ("fh", _numpy.intp, ),
+    ("opcode", _numpy.int32, ),
+    ("cookie", _numpy.intp, ),
+    ], align=True)
+
+
+cdef class IOParams:
+    """Empty-initialize an array of `CUfileIOParams_t`.
+
+    The resulting object is of length `size` and of dtype `io_params_dtype`.
+    If default-constructed, the instance represents a single struct.
+
+    Args:
+        size (int): number of structs, default=1.
+
+
+    .. seealso:: `CUfileIOParams_t`
+    """
+    cdef:
+        readonly object _data
+
+    def __init__(self, size=1):
+        arr = _numpy.empty(size, dtype=io_params_dtype)
+        self._data = arr.view(_numpy.recarray)
+        assert self._data.itemsize == sizeof(CUfileIOParams_t), \
+            f"itemsize {self._data.itemsize} mismatches struct size {sizeof(CUfileIOParams_t)}"
+
+    def __repr__(self):
+        if self._data.size > 1:
+            return f"<{__name__}.IOParams_Array_{self._data.size} object at {hex(id(self))}>"
+        else:
+            return f"<{__name__}.IOParams object at {hex(id(self))}>"
+
+    @property
+    def ptr(self):
+        """Get the pointer address to the data as Python :class:`int`."""
+        return self._data.ctypes.data
+
+    def __int__(self):
+        if self._data.size > 1:
+            raise TypeError("int() argument must be a bytes-like object of size 1. "
+                            "To get the pointer address of an array, use .ptr")
+        return self._data.ctypes.data
+
+    def __len__(self):
+        return self._data.size
+
+    def __eq__(self, other):
+        if not isinstance(other, IOParams):
+            return False
+        if self._data.size != other._data.size:
+            return False
+        if self._data.dtype != other._data.dtype:
+            return False
+        return bool((self._data == other._data).all())
+
+    @property
+    def mode(self):
+        """Union[~_numpy.int32, int]: """
+        if self._data.size == 1:
+            return int(self._data.mode[0])
+        return self._data.mode
+
+    @mode.setter
+    def mode(self, val):
+        self._data.mode = val
+
+    @property
+    def u(self):
+        """_py_anon_pod2_dtype: """
+        return self._data.u
+
+    @u.setter
+    def u(self, val):
+        self._data.u = val
+
+    @property
+    def fh(self):
+        """Union[~_numpy.intp, int]: """
+        if self._data.size == 1:
+            return int(self._data.fh[0])
+        return self._data.fh
+
+    @fh.setter
+    def fh(self, val):
+        self._data.fh = val
+
+    @property
+    def opcode(self):
+        """Union[~_numpy.int32, int]: """
+        if self._data.size == 1:
+            return int(self._data.opcode[0])
+        return self._data.opcode
+
+    @opcode.setter
+    def opcode(self, val):
+        self._data.opcode = val
+
+    @property
+    def cookie(self):
+        """Union[~_numpy.intp, int]: """
+        if self._data.size == 1:
+            return int(self._data.cookie[0])
+        return self._data.cookie
+
+    @cookie.setter
+    def cookie(self, val):
+        self._data.cookie = val
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            size = self._data.size
+            if key >= size or key <= -(size+1):
+                raise IndexError("index is out of bounds")
+            if key < 0:
+                key += size
+            return IOParams.from_data(self._data[key:key+1])
+        out = self._data[key]
+        if isinstance(out, _numpy.recarray) and out.dtype == io_params_dtype:
+            return IOParams.from_data(out)
+        return out
+
+    def __setitem__(self, key, val):
+        self._data[key] = val
+
+    @staticmethod
+    def from_data(data):
+        """Create an IOParams instance wrapping the given NumPy array.
+
+        Args:
+            data (_numpy.ndarray): a 1D array of dtype `io_params_dtype` holding the data.
+        """
+        cdef IOParams obj = IOParams.__new__(IOParams)
+        if not isinstance(data, (_numpy.ndarray, _numpy.recarray)):
+            raise TypeError("data argument must be a NumPy ndarray")
+        if data.ndim != 1:
+            raise ValueError("data array must be 1D")
+        if data.dtype != io_params_dtype:
+            raise ValueError("data array must be of dtype io_params_dtype")
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+    @staticmethod
+    def from_ptr(intptr_t ptr, size_t size=1, bint readonly=False):
+        """Create an IOParams instance wrapping the given pointer.
+
+        Args:
+            ptr (intptr_t): pointer address as Python :class:`int` to the data.
+            size (int): number of structs, default=1.
+            readonly (bool): whether the data is read-only (to the user). default is `False`.
+        """
+        if ptr == 0:
+            raise ValueError("ptr must not be null (0)")
+        cdef IOParams obj = IOParams.__new__(IOParams)
+        cdef flag = _buffer.PyBUF_READ if readonly else _buffer.PyBUF_WRITE
+        cdef object buf = PyMemoryView_FromMemory(
+            <char*>ptr, sizeof(CUfileIOParams_t) * size, flag)
+        data = _numpy.ndarray((size,), buffer=buf,
+                              dtype=io_params_dtype)
+        obj._data = data.view(_numpy.recarray)
+
+        return obj
+
+
+# Hack: Overwrite the generated descr_dtype, which NumPy deduced the offset wrong.
+descr_dtype = _numpy.dtype({
+    "names": ['type', 'handle', 'fs_ops'],
+    "formats": [_numpy.int32, _py_anon_pod1_dtype, _numpy.intp],
+    "offsets": [0, 8, 16],
+}, align=True)
+
+# Hack: Overwrite the generated io_params_dtype, which NumPy deduced the offset wrong.
+io_params_dtype = _numpy.dtype({
+    "names": ['mode', 'u', 'fh', 'opcode', 'cookie'],
+    "formats": [_numpy.int32, _py_anon_pod2_dtype, _numpy.intp, _numpy.int32, _numpy.intp],
+    "offsets": [0, 8, 40, 48, 56],
+}, align=True)
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+class OpError(_IntEnum):
+    """See `CUfileOpError`."""
+    SUCCESS = CU_FILE_SUCCESS
+    DRIVER_NOT_INITIALIZED = CU_FILE_DRIVER_NOT_INITIALIZED
+    DRIVER_INVALID_PROPS = CU_FILE_DRIVER_INVALID_PROPS
+    DRIVER_UNSUPPORTED_LIMIT = CU_FILE_DRIVER_UNSUPPORTED_LIMIT
+    DRIVER_VERSION_MISMATCH = CU_FILE_DRIVER_VERSION_MISMATCH
+    DRIVER_VERSION_READ_ERROR = CU_FILE_DRIVER_VERSION_READ_ERROR
+    DRIVER_CLOSING = CU_FILE_DRIVER_CLOSING
+    PLATFORM_NOT_SUPPORTED = CU_FILE_PLATFORM_NOT_SUPPORTED
+    IO_NOT_SUPPORTED = CU_FILE_IO_NOT_SUPPORTED
+    DEVICE_NOT_SUPPORTED = CU_FILE_DEVICE_NOT_SUPPORTED
+    NVFS_DRIVER_ERROR = CU_FILE_NVFS_DRIVER_ERROR
+    CUDA_DRIVER_ERROR = CU_FILE_CUDA_DRIVER_ERROR
+    CUDA_POINTER_INVALID = CU_FILE_CUDA_POINTER_INVALID
+    CUDA_MEMORY_TYPE_INVALID = CU_FILE_CUDA_MEMORY_TYPE_INVALID
+    CUDA_POINTER_RANGE_ERROR = CU_FILE_CUDA_POINTER_RANGE_ERROR
+    CUDA_CONTEXT_MISMATCH = CU_FILE_CUDA_CONTEXT_MISMATCH
+    INVALID_MAPPING_SIZE = CU_FILE_INVALID_MAPPING_SIZE
+    INVALID_MAPPING_RANGE = CU_FILE_INVALID_MAPPING_RANGE
+    INVALID_FILE_TYPE = CU_FILE_INVALID_FILE_TYPE
+    INVALID_FILE_OPEN_FLAG = CU_FILE_INVALID_FILE_OPEN_FLAG
+    DIO_NOT_SET = CU_FILE_DIO_NOT_SET
+    INVALID_VALUE = CU_FILE_INVALID_VALUE
+    MEMORY_ALREADY_REGISTERED = CU_FILE_MEMORY_ALREADY_REGISTERED
+    MEMORY_NOT_REGISTERED = CU_FILE_MEMORY_NOT_REGISTERED
+    PERMISSION_DENIED = CU_FILE_PERMISSION_DENIED
+    DRIVER_ALREADY_OPEN = CU_FILE_DRIVER_ALREADY_OPEN
+    HANDLE_NOT_REGISTERED = CU_FILE_HANDLE_NOT_REGISTERED
+    HANDLE_ALREADY_REGISTERED = CU_FILE_HANDLE_ALREADY_REGISTERED
+    DEVICE_NOT_FOUND = CU_FILE_DEVICE_NOT_FOUND
+    INTERNAL_ERROR = CU_FILE_INTERNAL_ERROR
+    GETNEWFD_FAILED = CU_FILE_GETNEWFD_FAILED
+    NVFS_SETUP_ERROR = CU_FILE_NVFS_SETUP_ERROR
+    IO_DISABLED = CU_FILE_IO_DISABLED
+    BATCH_SUBMIT_FAILED = CU_FILE_BATCH_SUBMIT_FAILED
+    GPU_MEMORY_PINNING_FAILED = CU_FILE_GPU_MEMORY_PINNING_FAILED
+    BATCH_FULL = CU_FILE_BATCH_FULL
+    ASYNC_NOT_SUPPORTED = CU_FILE_ASYNC_NOT_SUPPORTED
+    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
+    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
+
+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
+
+class FileHandleType(_IntEnum):
+    """See `CUfileFileHandleType`."""
+    OPAQUE_FD = CU_FILE_HANDLE_TYPE_OPAQUE_FD
+    OPAQUE_WIN32 = CU_FILE_HANDLE_TYPE_OPAQUE_WIN32
+    USERSPACE_FS = CU_FILE_HANDLE_TYPE_USERSPACE_FS
+
+class Opcode(_IntEnum):
+    """See `CUfileOpcode_t`."""
+    READ = CUFILE_READ
+    WRITE = CUFILE_WRITE
+
+class Status(_IntEnum):
+    """See `CUfileStatus_t`."""
+    WAITING = CUFILE_WAITING
+    PENDING = CUFILE_PENDING
+    INVALID = CUFILE_INVALID
+    CANCELED = CUFILE_CANCELED
+    COMPLETE = CUFILE_COMPLETE
+    TIMEOUT = CUFILE_TIMEOUT
+    FAILED = CUFILE_FAILED
+
+class BatchMode(_IntEnum):
+    """See `CUfileBatchMode_t`."""
+    BATCH = CUFILE_BATCH
+
+class SizeTConfigParameter(_IntEnum):
+    """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
+    EXECUTION_MIN_IO_THRESHOLD_SIZE_KB = CUFILE_PARAM_EXECUTION_MIN_IO_THRESHOLD_SIZE_KB
+    EXECUTION_MAX_REQUEST_PARALLELISM = CUFILE_PARAM_EXECUTION_MAX_REQUEST_PARALLELISM
+    PROPERTIES_MAX_DIRECT_IO_SIZE_KB = CUFILE_PARAM_PROPERTIES_MAX_DIRECT_IO_SIZE_KB
+    PROPERTIES_MAX_DEVICE_CACHE_SIZE_KB = CUFILE_PARAM_PROPERTIES_MAX_DEVICE_CACHE_SIZE_KB
+    PROPERTIES_PER_BUFFER_CACHE_SIZE_KB = CUFILE_PARAM_PROPERTIES_PER_BUFFER_CACHE_SIZE_KB
+    PROPERTIES_MAX_DEVICE_PINNED_MEM_SIZE_KB = CUFILE_PARAM_PROPERTIES_MAX_DEVICE_PINNED_MEM_SIZE_KB
+    PROPERTIES_IO_BATCHSIZE = CUFILE_PARAM_PROPERTIES_IO_BATCHSIZE
+    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`."""
+    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
+    FS_MISC_API_CHECK_AGGRESSIVE = CUFILE_PARAM_FS_MISC_API_CHECK_AGGRESSIVE
+    EXECUTION_PARALLEL_IO = CUFILE_PARAM_EXECUTION_PARALLEL_IO
+    PROFILE_NVTX = CUFILE_PARAM_PROFILE_NVTX
+    PROPERTIES_ALLOW_SYSTEM_MEMORY = CUFILE_PARAM_PROPERTIES_ALLOW_SYSTEM_MEMORY
+    USE_PCIP2PDMA = CUFILE_PARAM_USE_PCIP2PDMA
+    PREFER_IO_URING = CUFILE_PARAM_PREFER_IO_URING
+    FORCE_ODIRECT_MODE = CUFILE_PARAM_FORCE_ODIRECT_MODE
+    SKIP_TOPOLOGY_DETECTION = CUFILE_PARAM_SKIP_TOPOLOGY_DETECTION
+    STREAM_MEMOPS_BYPASS = CUFILE_PARAM_STREAM_MEMOPS_BYPASS
+
+class StringConfigParameter(_IntEnum):
+    """See `CUFileStringConfigParameter_t`."""
+    LOGGING_LEVEL = CUFILE_PARAM_LOGGING_LEVEL
+    ENV_LOGFILE_PATH = CUFILE_PARAM_ENV_LOGFILE_PATH
+    LOG_DIR = CUFILE_PARAM_LOG_DIR
+
+
+###############################################################################
+# Error handling
+###############################################################################
+
+ctypedef fused ReturnT:
+    CUfileError_t
+    ssize_t
+
+
+class cuFileError(Exception):
+
+    def __init__(self, status, cu_err=None):
+        self.status = status
+        self.cuda_error = cu_err
+        s = OpError(status)
+        cdef str err = f"{s.name} ({s.value}): {op_status_error(status)}"
+        if cu_err is not None:
+            e = pyCUresult(cu_err)
+            err += f"; CUDA status: {e.name} ({e.value})"
+        super(cuFileError, self).__init__(err)
+
+    def __reduce__(self):
+        return (type(self), (self.status, self.cuda_error))
+
+
+@cython.profile(False)
+cdef int check_status(ReturnT status) except 1 nogil:
+    if ReturnT is CUfileError_t:
+        if status.err != 0 or status.cu_err != 0:
+            with gil:
+                raise cuFileError(status.err, status.cu_err)
+    elif ReturnT is ssize_t:
+        if status == -1:
+            # note: this assumes cuFile already properly resets errno in each API
+            with gil:
+                raise cuFileError(errno.errno)
+    return 0
+
+
+###############################################################################
+# Wrapper functions
+###############################################################################
+
+cpdef intptr_t handle_register(intptr_t descr) except? 0:
+    """cuFileHandleRegister is required, and performs extra checking that is memoized to provide increased performance on later cuFile operations.
+
+    Args:
+        descr (intptr_t): ``CUfileDescr_t`` file descriptor (OS agnostic).
+
+    Returns:
+        intptr_t: ``CUfileHandle_t`` opaque file handle for IO operations.
+
+    .. seealso:: `cuFileHandleRegister`
+    """
+    cdef Handle fh
+    with nogil:
+        status = cuFileHandleRegister(&fh, <CUfileDescr_t*>descr)
+    check_status(status)
+    return <intptr_t>fh
+
+
+cpdef void handle_deregister(intptr_t fh) except*:
+    """releases a registered filehandle from cuFile.
+
+    Args:
+        fh (intptr_t): ``CUfileHandle_t`` file handle.
+
+    .. seealso:: `cuFileHandleDeregister`
+    """
+    cuFileHandleDeregister(<Handle>fh)
+
+
+cpdef buf_register(intptr_t buf_ptr_base, size_t length, int flags):
+    """register an existing cudaMalloced memory with cuFile to pin for GPUDirect Storage access or register host allocated memory with cuFile.
+
+    Args:
+        buf_ptr_base (intptr_t): buffer pointer allocated.
+        length (size_t): size of memory region from the above specified bufPtr.
+        flags (int): CU_FILE_RDMA_REGISTER.
+
+    .. seealso:: `cuFileBufRegister`
+    """
+    with nogil:
+        status = cuFileBufRegister(<const void*>buf_ptr_base, length, flags)
+    check_status(status)
+
+
+cpdef buf_deregister(intptr_t buf_ptr_base):
+    """deregister an already registered device or host memory from cuFile.
+
+    Args:
+        buf_ptr_base (intptr_t): buffer pointer to deregister.
+
+    .. seealso:: `cuFileBufDeregister`
+    """
+    with nogil:
+        status = cuFileBufDeregister(<const void*>buf_ptr_base)
+    check_status(status)
+
+
+cpdef read(intptr_t fh, intptr_t buf_ptr_base, size_t size, off_t file_offset, off_t buf_ptr_offset):
+    """read data from a registered file handle to a specified device or host memory.
+
+    Args:
+        fh (intptr_t): ``CUfileHandle_t`` opaque file handle.
+        buf_ptr_base (intptr_t): base address of buffer in device or host memory.
+        size (size_t): size bytes to read.
+        file_offset (off_t): file-offset from begining of the file.
+        buf_ptr_offset (off_t): offset relative to the buf_ptr_base pointer to read into.
+
+    .. seealso:: `cuFileRead`
+    """
+    with nogil:
+        status = cuFileRead(<Handle>fh, <void*>buf_ptr_base, size, file_offset, buf_ptr_offset)
+    check_status(status)
+
+
+cpdef write(intptr_t fh, intptr_t buf_ptr_base, size_t size, off_t file_offset, off_t buf_ptr_offset):
+    """write data from a specified device or host memory to a registered file handle.
+
+    Args:
+        fh (intptr_t): ``CUfileHandle_t`` opaque file handle.
+        buf_ptr_base (intptr_t): base address of buffer in device or host memory.
+        size (size_t): size bytes to write.
+        file_offset (off_t): file-offset from begining of the file.
+        buf_ptr_offset (off_t): offset relative to the buf_ptr_base pointer to write from.
+
+    .. seealso:: `cuFileWrite`
+    """
+    with nogil:
+        status = cuFileWrite(<Handle>fh, <const void*>buf_ptr_base, size, file_offset, buf_ptr_offset)
+    check_status(status)
+
+
+cpdef driver_open():
+    """Initialize the cuFile library and open the nvidia-fs driver.
+
+    .. seealso:: `cuFileDriverOpen`
+    """
+    with nogil:
+        status = cuFileDriverOpen()
+    check_status(status)
+
+
+cpdef use_count():
+    """returns use count of cufile drivers at that moment by the process.
+
+    .. seealso:: `cuFileUseCount`
+    """
+    with nogil:
+        status = cuFileUseCount()
+    check_status(status)
+
+
+cpdef driver_get_properties(intptr_t props):
+    """Gets the Driver session properties.
+
+    Args:
+        props (intptr_t): to set.
+
+    .. seealso:: `cuFileDriverGetProperties`
+    """
+    with nogil:
+        status = cuFileDriverGetProperties(<CUfileDrvProps_t*>props)
+    check_status(status)
+
+
+cpdef driver_set_poll_mode(bint poll, size_t poll_threshold_size):
+    """Sets whether the Read/Write APIs use polling to do IO operations.
+
+    Args:
+        poll (bint): boolean to indicate whether to use poll mode or not.
+        poll_threshold_size (size_t): max IO size to use for POLLING mode in KB.
+
+    .. seealso:: `cuFileDriverSetPollMode`
+    """
+    with nogil:
+        status = cuFileDriverSetPollMode(<cpp_bool>poll, poll_threshold_size)
+    check_status(status)
+
+
+cpdef driver_set_max_direct_io_size(size_t max_direct_io_size):
+    """Control parameter to set max IO size(KB) used by the library to talk to nvidia-fs driver.
+
+    Args:
+        max_direct_io_size (size_t): maximum allowed direct io size in KB.
+
+    .. seealso:: `cuFileDriverSetMaxDirectIOSize`
+    """
+    with nogil:
+        status = cuFileDriverSetMaxDirectIOSize(max_direct_io_size)
+    check_status(status)
+
+
+cpdef driver_set_max_cache_size(size_t max_cache_size):
+    """Control parameter to set maximum GPU memory reserved per device by the library for internal buffering.
+
+    Args:
+        max_cache_size (size_t): The maximum GPU buffer space per device used for internal use in KB.
+
+    .. seealso:: `cuFileDriverSetMaxCacheSize`
+    """
+    with nogil:
+        status = cuFileDriverSetMaxCacheSize(max_cache_size)
+    check_status(status)
+
+
+cpdef driver_set_max_pinned_mem_size(size_t max_pinned_size):
+    """Sets maximum buffer space that is pinned in KB for use by ``cuFileBufRegister``.
+
+    Args:
+        max_pinned_size (size_t): maximum buffer space that is pinned in KB.
+
+    .. seealso:: `cuFileDriverSetMaxPinnedMemSize`
+    """
+    with nogil:
+        status = cuFileDriverSetMaxPinnedMemSize(max_pinned_size)
+    check_status(status)
+
+
+cpdef intptr_t batch_io_set_up(unsigned nr) except? 0:
+    cdef BatchHandle batch_idp
+    with nogil:
+        status = cuFileBatchIOSetUp(&batch_idp, nr)
+    check_status(status)
+    return <intptr_t>batch_idp
+
+
+cpdef batch_io_submit(intptr_t batch_idp, unsigned nr, intptr_t iocbp, unsigned int flags):
+    with nogil:
+        status = cuFileBatchIOSubmit(<BatchHandle>batch_idp, nr, <CUfileIOParams_t*>iocbp, flags)
+    check_status(status)
+
+
+cpdef batch_io_get_status(intptr_t batch_idp, unsigned min_nr, intptr_t nr, intptr_t iocbp, intptr_t timeout):
+    with nogil:
+        status = cuFileBatchIOGetStatus(<BatchHandle>batch_idp, min_nr, <unsigned*>nr, <CUfileIOEvents_t*>iocbp, <timespec*>timeout)
+    check_status(status)
+
+
+cpdef batch_io_cancel(intptr_t batch_idp):
+    with nogil:
+        status = cuFileBatchIOCancel(<BatchHandle>batch_idp)
+    check_status(status)
+
+
+cpdef void batch_io_destroy(intptr_t batch_idp) except*:
+    cuFileBatchIODestroy(<BatchHandle>batch_idp)
+
+
+cpdef read_async(intptr_t fh, intptr_t buf_ptr_base, intptr_t size_p, intptr_t file_offset_p, intptr_t buf_ptr_offset_p, intptr_t bytes_read_p, intptr_t stream):
+    with nogil:
+        status = cuFileReadAsync(<Handle>fh, <void*>buf_ptr_base, <size_t*>size_p, <off_t*>file_offset_p, <off_t*>buf_ptr_offset_p, <ssize_t*>bytes_read_p, <void*>stream)
+    check_status(status)
+
+
+cpdef write_async(intptr_t fh, intptr_t buf_ptr_base, intptr_t size_p, intptr_t file_offset_p, intptr_t buf_ptr_offset_p, intptr_t bytes_written_p, intptr_t stream):
+    with nogil:
+        status = cuFileWriteAsync(<Handle>fh, <void*>buf_ptr_base, <size_t*>size_p, <off_t*>file_offset_p, <off_t*>buf_ptr_offset_p, <ssize_t*>bytes_written_p, <void*>stream)
+    check_status(status)
+
+
+cpdef stream_register(intptr_t stream, unsigned flags):
+    with nogil:
+        status = cuFileStreamRegister(<void*>stream, flags)
+    check_status(status)
+
+
+cpdef stream_deregister(intptr_t stream):
+    with nogil:
+        status = cuFileStreamDeregister(<void*>stream)
+    check_status(status)
+
+
+cpdef int get_version() except? 0:
+    cdef int version
+    with nogil:
+        status = cuFileGetVersion(&version)
+    check_status(status)
+    return version
+
+
+cpdef size_t get_parameter_size_t(int param) except? 0:
+    cdef size_t value
+    with nogil:
+        status = cuFileGetParameterSizeT(<_SizeTConfigParameter>param, &value)
+    check_status(status)
+    return value
+
+
+cpdef bint get_parameter_bool(int param) except? 0:
+    cdef cpp_bool value
+    with nogil:
+        status = cuFileGetParameterBool(<_BoolConfigParameter>param, &value)
+    check_status(status)
+    return <bint>value
+
+
+cpdef str get_parameter_string(int param, int len):
+    cdef bytes _desc_str_ = bytes(len)
+    cdef char* desc_str = _desc_str_
+    with nogil:
+        status = cuFileGetParameterString(<_StringConfigParameter>param, desc_str, len)
+    check_status(status)
+    return _desc_str_.decode()
+
+
+cpdef set_parameter_size_t(int param, size_t value):
+    with nogil:
+        status = cuFileSetParameterSizeT(<_SizeTConfigParameter>param, value)
+    check_status(status)
+
+
+cpdef set_parameter_bool(int param, bint value):
+    with nogil:
+        status = cuFileSetParameterBool(<_BoolConfigParameter>param, <cpp_bool>value)
+    check_status(status)
+
+
+cpdef set_parameter_string(int param, intptr_t desc_str):
+    with nogil:
+        status = cuFileSetParameterString(<_StringConfigParameter>param, <const char*>desc_str)
+    check_status(status)
+
+
+cpdef str op_status_error(int status):
+    """cufileop status string.
+
+    Args:
+        status (OpError): the error status to query.
+
+    .. seealso:: `cufileop_status_error`
+    """
+    cdef bytes _output_
+    _output_ = cufileop_status_error(<_OpError>status)
+    return _output_.decode()
+
+
+cpdef driver_close():
+    """reset the cuFile library and release the nvidia-fs driver
+    """
+    with nogil:
+        status = cuFileDriverClose_v2()
+    check_status(status)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cycufile.pxd

@@ -0,0 +1,258 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.9.0 to 12.9.1. Do not modify it directly.
+
+from libc.stdint cimport uint32_t, uint64_t
+from libc.time cimport time_t
+from libcpp cimport bool as cpp_bool
+from posix.types cimport off_t
+
+cimport cuda.bindings.cydriver
+from cuda.bindings.cydriver cimport CUresult
+
+
+###############################################################################
+# Types (structs, enums, ...)
+###############################################################################
+
+# TODO: switch to "from libc.time cimport timespec" once we can use recent
+# Cython to build
+cdef extern from "<time.h>":
+    cdef struct timespec:
+        time_t tv_sec
+        long   tv_nsec
+cdef extern from "<sys/socket.h>":
+    cdef struct sockaddr:
+        unsigned short sa_family
+        char sa_data[14]
+    ctypedef sockaddr sockaddr_t
+
+
+cdef extern from '<cufile.h>':
+    # enums
+    ctypedef enum CUfileOpError:
+        CU_FILE_SUCCESS
+        CU_FILE_DRIVER_NOT_INITIALIZED
+        CU_FILE_DRIVER_INVALID_PROPS
+        CU_FILE_DRIVER_UNSUPPORTED_LIMIT
+        CU_FILE_DRIVER_VERSION_MISMATCH
+        CU_FILE_DRIVER_VERSION_READ_ERROR
+        CU_FILE_DRIVER_CLOSING
+        CU_FILE_PLATFORM_NOT_SUPPORTED
+        CU_FILE_IO_NOT_SUPPORTED
+        CU_FILE_DEVICE_NOT_SUPPORTED
+        CU_FILE_NVFS_DRIVER_ERROR
+        CU_FILE_CUDA_DRIVER_ERROR
+        CU_FILE_CUDA_POINTER_INVALID
+        CU_FILE_CUDA_MEMORY_TYPE_INVALID
+        CU_FILE_CUDA_POINTER_RANGE_ERROR
+        CU_FILE_CUDA_CONTEXT_MISMATCH
+        CU_FILE_INVALID_MAPPING_SIZE
+        CU_FILE_INVALID_MAPPING_RANGE
+        CU_FILE_INVALID_FILE_TYPE
+        CU_FILE_INVALID_FILE_OPEN_FLAG
+        CU_FILE_DIO_NOT_SET
+        CU_FILE_INVALID_VALUE
+        CU_FILE_MEMORY_ALREADY_REGISTERED
+        CU_FILE_MEMORY_NOT_REGISTERED
+        CU_FILE_PERMISSION_DENIED
+        CU_FILE_DRIVER_ALREADY_OPEN
+        CU_FILE_HANDLE_NOT_REGISTERED
+        CU_FILE_HANDLE_ALREADY_REGISTERED
+        CU_FILE_DEVICE_NOT_FOUND
+        CU_FILE_INTERNAL_ERROR
+        CU_FILE_GETNEWFD_FAILED
+        CU_FILE_NVFS_SETUP_ERROR
+        CU_FILE_IO_DISABLED
+        CU_FILE_BATCH_SUBMIT_FAILED
+        CU_FILE_GPU_MEMORY_PINNING_FAILED
+        CU_FILE_BATCH_FULL
+        CU_FILE_ASYNC_NOT_SUPPORTED
+        CU_FILE_IO_MAX_ERROR
+
+    ctypedef enum CUfileDriverStatusFlags_t:
+        CU_FILE_LUSTRE_SUPPORTED
+        CU_FILE_WEKAFS_SUPPORTED
+        CU_FILE_NFS_SUPPORTED
+        CU_FILE_GPFS_SUPPORTED
+        CU_FILE_NVME_SUPPORTED
+        CU_FILE_NVMEOF_SUPPORTED
+        CU_FILE_SCSI_SUPPORTED
+        CU_FILE_SCALEFLUX_CSD_SUPPORTED
+        CU_FILE_NVMESH_SUPPORTED
+        CU_FILE_BEEGFS_SUPPORTED
+        CU_FILE_NVME_P2P_SUPPORTED
+        CU_FILE_SCATEFS_SUPPORTED
+
+    ctypedef enum CUfileDriverControlFlags_t:
+        CU_FILE_USE_POLL_MODE
+        CU_FILE_ALLOW_COMPAT_MODE
+
+    ctypedef enum CUfileFeatureFlags_t:
+        CU_FILE_DYN_ROUTING_SUPPORTED
+        CU_FILE_BATCH_IO_SUPPORTED
+        CU_FILE_STREAMS_SUPPORTED
+        CU_FILE_PARALLEL_IO_SUPPORTED
+
+    ctypedef enum CUfileFileHandleType:
+        CU_FILE_HANDLE_TYPE_OPAQUE_FD
+        CU_FILE_HANDLE_TYPE_OPAQUE_WIN32
+        CU_FILE_HANDLE_TYPE_USERSPACE_FS
+
+    ctypedef enum CUfileOpcode_t:
+        CUFILE_READ
+        CUFILE_WRITE
+
+    ctypedef enum CUfileStatus_t:
+        CUFILE_WAITING
+        CUFILE_PENDING
+        CUFILE_INVALID
+        CUFILE_CANCELED
+        CUFILE_COMPLETE
+        CUFILE_TIMEOUT
+        CUFILE_FAILED
+
+    ctypedef enum CUfileBatchMode_t:
+        CUFILE_BATCH
+
+    ctypedef enum CUFileSizeTConfigParameter_t:
+        CUFILE_PARAM_PROFILE_STATS
+        CUFILE_PARAM_EXECUTION_MAX_IO_QUEUE_DEPTH
+        CUFILE_PARAM_EXECUTION_MAX_IO_THREADS
+        CUFILE_PARAM_EXECUTION_MIN_IO_THRESHOLD_SIZE_KB
+        CUFILE_PARAM_EXECUTION_MAX_REQUEST_PARALLELISM
+        CUFILE_PARAM_PROPERTIES_MAX_DIRECT_IO_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_MAX_DEVICE_CACHE_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_PER_BUFFER_CACHE_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_MAX_DEVICE_PINNED_MEM_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_IO_BATCHSIZE
+        CUFILE_PARAM_POLLTHRESHOLD_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_BATCH_IO_TIMEOUT_MS
+
+    ctypedef enum CUFileBoolConfigParameter_t:
+        CUFILE_PARAM_PROPERTIES_USE_POLL_MODE
+        CUFILE_PARAM_PROPERTIES_ALLOW_COMPAT_MODE
+        CUFILE_PARAM_FORCE_COMPAT_MODE
+        CUFILE_PARAM_FS_MISC_API_CHECK_AGGRESSIVE
+        CUFILE_PARAM_EXECUTION_PARALLEL_IO
+        CUFILE_PARAM_PROFILE_NVTX
+        CUFILE_PARAM_PROPERTIES_ALLOW_SYSTEM_MEMORY
+        CUFILE_PARAM_USE_PCIP2PDMA
+        CUFILE_PARAM_PREFER_IO_URING
+        CUFILE_PARAM_FORCE_ODIRECT_MODE
+        CUFILE_PARAM_SKIP_TOPOLOGY_DETECTION
+        CUFILE_PARAM_STREAM_MEMOPS_BYPASS
+
+    ctypedef enum CUFileStringConfigParameter_t:
+        CUFILE_PARAM_LOGGING_LEVEL
+        CUFILE_PARAM_ENV_LOGFILE_PATH
+        CUFILE_PARAM_LOG_DIR
+
+    # types
+    ctypedef void* CUfileHandle_t 'CUfileHandle_t'
+    ctypedef void* CUfileBatchHandle_t 'CUfileBatchHandle_t'
+    ctypedef struct CUfileError_t 'CUfileError_t':
+        CUfileOpError err
+        CUresult cu_err
+    cdef struct _anon_pod0 '_anon_pod0':
+        unsigned int major_version
+        unsigned int minor_version
+        size_t poll_thresh_size
+        size_t max_direct_io_size
+        unsigned int dstatusflags
+        unsigned int dcontrolflags
+    ctypedef struct cufileRDMAInfo_t 'cufileRDMAInfo_t':
+        int version
+        int desc_len
+        char* desc_str
+    ctypedef struct CUfileFSOps_t 'CUfileFSOps_t':
+        char* (*fs_type)(void*)
+        int (*getRDMADeviceList)(void*, sockaddr_t**)
+        int (*getRDMADevicePriority)(void*, char*, size_t, loff_t, sockaddr_t*)
+        ssize_t (*read)(void*, char*, size_t, loff_t, cufileRDMAInfo_t*)
+        ssize_t (*write)(void*, const char*, size_t, loff_t, cufileRDMAInfo_t*)
+    cdef union _anon_pod1 '_anon_pod1':
+        int fd
+        void* handle
+    cdef struct _anon_pod3 '_anon_pod3':
+        void* devPtr_base
+        off_t file_offset
+        off_t devPtr_offset
+        size_t size
+    ctypedef struct CUfileIOEvents_t 'CUfileIOEvents_t':
+        void* cookie
+        CUfileStatus_t status
+        size_t ret
+    ctypedef struct CUfileDrvProps_t 'CUfileDrvProps_t':
+        _anon_pod0 nvfs
+        unsigned int fflags
+        unsigned int max_device_cache_size
+        unsigned int per_buffer_cache_size
+        unsigned int max_device_pinned_mem_size
+        unsigned int max_batch_io_size
+        unsigned int max_batch_io_timeout_msecs
+    ctypedef struct CUfileDescr_t 'CUfileDescr_t':
+        CUfileFileHandleType type
+        _anon_pod1 handle
+        CUfileFSOps_t* fs_ops
+    cdef union _anon_pod2 '_anon_pod2':
+        _anon_pod3 batch
+    ctypedef struct CUfileIOParams_t 'CUfileIOParams_t':
+        CUfileBatchMode_t mode
+        _anon_pod2 u
+        CUfileHandle_t fh
+        CUfileOpcode_t opcode
+        void* cookie
+
+
+cdef extern from *:
+    """
+    // This is the missing piece we need to supply to help Cython & C++ compilers.
+    inline bool operator==(const CUfileError_t& lhs, const CUfileError_t& rhs) {
+        return (lhs.err == rhs.err) && (lhs.cu_err == rhs.cu_err);
+    }
+    static CUfileError_t CUFILE_LOADING_ERROR{(CUfileOpError)-1, (CUresult)-1};
+    """
+    const CUfileError_t CUFILE_LOADING_ERROR
+    ctypedef void* CUstream "CUstream"
+
+    const char* cufileop_status_error(CUfileOpError)
+
+
+###############################################################################
+# Functions
+###############################################################################
+
+cdef CUfileError_t cuFileHandleRegister(CUfileHandle_t* fh, CUfileDescr_t* descr) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef void cuFileHandleDeregister(CUfileHandle_t fh) except* nogil
+cdef CUfileError_t cuFileBufRegister(const void* bufPtr_base, size_t length, int flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBufDeregister(const void* bufPtr_base) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef ssize_t cuFileRead(CUfileHandle_t fh, void* bufPtr_base, size_t size, off_t file_offset, off_t bufPtr_offset) except* nogil
+cdef ssize_t cuFileWrite(CUfileHandle_t fh, const void* bufPtr_base, size_t size, off_t file_offset, off_t bufPtr_offset) except* nogil
+cdef CUfileError_t cuFileDriverOpen() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverClose_v2() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef long cuFileUseCount() except* nogil
+cdef CUfileError_t cuFileDriverGetProperties(CUfileDrvProps_t* props) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverSetMaxDirectIOSize(size_t max_direct_io_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverSetMaxCacheSize(size_t max_cache_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverSetMaxPinnedMemSize(size_t max_pinned_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBatchIOSetUp(CUfileBatchHandle_t* batch_idp, unsigned nr) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBatchIOSubmit(CUfileBatchHandle_t batch_idp, unsigned nr, CUfileIOParams_t* iocbp, unsigned int flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBatchIOGetStatus(CUfileBatchHandle_t batch_idp, unsigned min_nr, unsigned* nr, CUfileIOEvents_t* iocbp, timespec* timeout) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBatchIOCancel(CUfileBatchHandle_t batch_idp) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef void cuFileBatchIODestroy(CUfileBatchHandle_t batch_idp) except* nogil
+cdef CUfileError_t cuFileReadAsync(CUfileHandle_t fh, void* bufPtr_base, size_t* size_p, off_t* file_offset_p, off_t* bufPtr_offset_p, ssize_t* bytes_read_p, CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileWriteAsync(CUfileHandle_t fh, void* bufPtr_base, size_t* size_p, off_t* file_offset_p, off_t* bufPtr_offset_p, ssize_t* bytes_written_p, CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileStreamRegister(CUstream stream, unsigned flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileStreamDeregister(CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetVersion(int* version) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetParameterString(CUFileStringConfigParameter_t param, char* desc_str, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileSetParameterString(CUFileStringConfigParameter_t param, const char* desc_str) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverClose() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cycufile.pyx

@@ -0,0 +1,138 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.9.0 to 12.9.1. Do not modify it directly.
+
+from ._internal cimport cufile as _cufile
+
+import cython
+
+###############################################################################
+# Wrapper functions
+###############################################################################
+
+cdef CUfileError_t cuFileHandleRegister(CUfileHandle_t* fh, CUfileDescr_t* descr) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileHandleRegister(fh, descr)
+
+
+@cython.show_performance_hints(False)
+cdef void cuFileHandleDeregister(CUfileHandle_t fh) except* nogil:
+    _cufile._cuFileHandleDeregister(fh)
+
+
+cdef CUfileError_t cuFileBufRegister(const void* bufPtr_base, size_t length, int flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileBufRegister(bufPtr_base, length, flags)
+
+
+cdef CUfileError_t cuFileBufDeregister(const void* bufPtr_base) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileBufDeregister(bufPtr_base)
+
+
+cdef ssize_t cuFileRead(CUfileHandle_t fh, void* bufPtr_base, size_t size, off_t file_offset, off_t bufPtr_offset) except* nogil:
+    return _cufile._cuFileRead(fh, bufPtr_base, size, file_offset, bufPtr_offset)
+
+
+cdef ssize_t cuFileWrite(CUfileHandle_t fh, const void* bufPtr_base, size_t size, off_t file_offset, off_t bufPtr_offset) except* nogil:
+    return _cufile._cuFileWrite(fh, bufPtr_base, size, file_offset, bufPtr_offset)
+
+
+cdef CUfileError_t cuFileDriverOpen() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileDriverOpen()
+
+
+cdef CUfileError_t cuFileDriverClose_v2() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileDriverClose_v2()
+
+
+cdef long cuFileUseCount() except* nogil:
+    return _cufile._cuFileUseCount()
+
+
+cdef CUfileError_t cuFileDriverGetProperties(CUfileDrvProps_t* props) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileDriverGetProperties(props)
+
+
+cdef CUfileError_t cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileDriverSetPollMode(poll, poll_threshold_size)
+
+
+cdef CUfileError_t cuFileDriverSetMaxDirectIOSize(size_t max_direct_io_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileDriverSetMaxDirectIOSize(max_direct_io_size)
+
+
+cdef CUfileError_t cuFileDriverSetMaxCacheSize(size_t max_cache_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileDriverSetMaxCacheSize(max_cache_size)
+
+
+cdef CUfileError_t cuFileDriverSetMaxPinnedMemSize(size_t max_pinned_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileDriverSetMaxPinnedMemSize(max_pinned_size)
+
+
+cdef CUfileError_t cuFileBatchIOSetUp(CUfileBatchHandle_t* batch_idp, unsigned nr) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileBatchIOSetUp(batch_idp, nr)
+
+
+cdef CUfileError_t cuFileBatchIOSubmit(CUfileBatchHandle_t batch_idp, unsigned nr, CUfileIOParams_t* iocbp, unsigned int flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileBatchIOSubmit(batch_idp, nr, iocbp, flags)
+
+
+cdef CUfileError_t cuFileBatchIOGetStatus(CUfileBatchHandle_t batch_idp, unsigned min_nr, unsigned* nr, CUfileIOEvents_t* iocbp, timespec* timeout) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileBatchIOGetStatus(batch_idp, min_nr, nr, iocbp, timeout)
+
+
+cdef CUfileError_t cuFileBatchIOCancel(CUfileBatchHandle_t batch_idp) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileBatchIOCancel(batch_idp)
+
+
+@cython.show_performance_hints(False)
+cdef void cuFileBatchIODestroy(CUfileBatchHandle_t batch_idp) except* nogil:
+    _cufile._cuFileBatchIODestroy(batch_idp)
+
+
+cdef CUfileError_t cuFileReadAsync(CUfileHandle_t fh, void* bufPtr_base, size_t* size_p, off_t* file_offset_p, off_t* bufPtr_offset_p, ssize_t* bytes_read_p, CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileReadAsync(fh, bufPtr_base, size_p, file_offset_p, bufPtr_offset_p, bytes_read_p, stream)
+
+
+cdef CUfileError_t cuFileWriteAsync(CUfileHandle_t fh, void* bufPtr_base, size_t* size_p, off_t* file_offset_p, off_t* bufPtr_offset_p, ssize_t* bytes_written_p, CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileWriteAsync(fh, bufPtr_base, size_p, file_offset_p, bufPtr_offset_p, bytes_written_p, stream)
+
+
+cdef CUfileError_t cuFileStreamRegister(CUstream stream, unsigned flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileStreamRegister(stream, flags)
+
+
+cdef CUfileError_t cuFileStreamDeregister(CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileStreamDeregister(stream)
+
+
+cdef CUfileError_t cuFileGetVersion(int* version) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileGetVersion(version)
+
+
+cdef CUfileError_t cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileGetParameterSizeT(param, value)
+
+
+cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileGetParameterBool(param, value)
+
+
+cdef CUfileError_t cuFileGetParameterString(CUFileStringConfigParameter_t param, char* desc_str, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileGetParameterString(param, desc_str, len)
+
+
+cdef CUfileError_t cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileSetParameterSizeT(param, value)
+
+
+cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileSetParameterBool(param, value)
+
+
+cdef CUfileError_t cuFileSetParameterString(CUFileStringConfigParameter_t param, const char* desc_str) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileSetParameterString(param, desc_str)
+
+
+cdef CUfileError_t cuFileDriverClose() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil:
+    return _cufile._cuFileDriverClose()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cynvjitlink.pyx

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.0.1 to 12.9.1. Do not modify it directly.
+
+from ._internal cimport nvjitlink as _nvjitlink
+
+
+###############################################################################
+# Wrapper functions
+###############################################################################
+
+cdef nvJitLinkResult nvJitLinkCreate(nvJitLinkHandle* handle, uint32_t numOptions, const char** options) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkCreate(handle, numOptions, options)
+
+
+cdef nvJitLinkResult nvJitLinkDestroy(nvJitLinkHandle* handle) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkDestroy(handle)
+
+
+cdef nvJitLinkResult nvJitLinkAddData(nvJitLinkHandle handle, nvJitLinkInputType inputType, const void* data, size_t size, const char* name) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkAddData(handle, inputType, data, size, name)
+
+
+cdef nvJitLinkResult nvJitLinkAddFile(nvJitLinkHandle handle, nvJitLinkInputType inputType, const char* fileName) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkAddFile(handle, inputType, fileName)
+
+
+cdef nvJitLinkResult nvJitLinkComplete(nvJitLinkHandle handle) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkComplete(handle)
+
+
+cdef nvJitLinkResult nvJitLinkGetLinkedCubinSize(nvJitLinkHandle handle, size_t* size) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkGetLinkedCubinSize(handle, size)
+
+
+cdef nvJitLinkResult nvJitLinkGetLinkedCubin(nvJitLinkHandle handle, void* cubin) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkGetLinkedCubin(handle, cubin)
+
+
+cdef nvJitLinkResult nvJitLinkGetLinkedPtxSize(nvJitLinkHandle handle, size_t* size) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkGetLinkedPtxSize(handle, size)
+
+
+cdef nvJitLinkResult nvJitLinkGetLinkedPtx(nvJitLinkHandle handle, char* ptx) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkGetLinkedPtx(handle, ptx)
+
+
+cdef nvJitLinkResult nvJitLinkGetErrorLogSize(nvJitLinkHandle handle, size_t* size) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkGetErrorLogSize(handle, size)
+
+
+cdef nvJitLinkResult nvJitLinkGetErrorLog(nvJitLinkHandle handle, char* log) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkGetErrorLog(handle, log)
+
+
+cdef nvJitLinkResult nvJitLinkGetInfoLogSize(nvJitLinkHandle handle, size_t* size) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkGetInfoLogSize(handle, size)
+
+
+cdef nvJitLinkResult nvJitLinkGetInfoLog(nvJitLinkHandle handle, char* log) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkGetInfoLog(handle, log)
+
+
+cdef nvJitLinkResult nvJitLinkVersion(unsigned int* major, unsigned int* minor) except?_NVJITLINKRESULT_INTERNAL_LOADING_ERROR nogil:
+    return _nvjitlink._nvJitLinkVersion(major, minor)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cynvrtc.pxd

@@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# This code was automatically generated with version 12.9.0. Do not modify it directly.
+
+from libc.stdint cimport uint32_t, uint64_t
+
+cdef extern from "nvrtc.h":
+
+    ctypedef enum nvrtcResult:
+        NVRTC_SUCCESS = 0
+        NVRTC_ERROR_OUT_OF_MEMORY = 1
+        NVRTC_ERROR_PROGRAM_CREATION_FAILURE = 2
+        NVRTC_ERROR_INVALID_INPUT = 3
+        NVRTC_ERROR_INVALID_PROGRAM = 4
+        NVRTC_ERROR_INVALID_OPTION = 5
+        NVRTC_ERROR_COMPILATION = 6
+        NVRTC_ERROR_BUILTIN_OPERATION_FAILURE = 7
+        NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION = 8
+        NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION = 9
+        NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID = 10
+        NVRTC_ERROR_INTERNAL_ERROR = 11
+        NVRTC_ERROR_TIME_FILE_WRITE_FAILED = 12
+        NVRTC_ERROR_NO_PCH_CREATE_ATTEMPTED = 13
+        NVRTC_ERROR_PCH_CREATE_HEAP_EXHAUSTED = 14
+        NVRTC_ERROR_PCH_CREATE = 15
+        NVRTC_ERROR_CANCELLED = 16
+
+    cdef struct _nvrtcProgram:
+        pass
+    ctypedef _nvrtcProgram* nvrtcProgram
+
+cdef const char* nvrtcGetErrorString(nvrtcResult result) except ?NULL nogil
+
+cdef nvrtcResult nvrtcVersion(int* major, int* minor) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetNumSupportedArchs(int* numArchs) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetSupportedArchs(int* supportedArchs) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcCreateProgram(nvrtcProgram* prog, const char* src, const char* name, int numHeaders, const char** headers, const char** includeNames) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcDestroyProgram(nvrtcProgram* prog) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcCompileProgram(nvrtcProgram prog, int numOptions, const char** options) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetPTXSize(nvrtcProgram prog, size_t* ptxSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetPTX(nvrtcProgram prog, char* ptx) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetCUBINSize(nvrtcProgram prog, size_t* cubinSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetCUBIN(nvrtcProgram prog, char* cubin) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetNVVMSize(nvrtcProgram prog, size_t* nvvmSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetNVVM(nvrtcProgram prog, char* nvvm) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetLTOIRSize(nvrtcProgram prog, size_t* LTOIRSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetLTOIR(nvrtcProgram prog, char* LTOIR) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetOptiXIRSize(nvrtcProgram prog, size_t* optixirSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetOptiXIR(nvrtcProgram prog, char* optixir) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetProgramLogSize(nvrtcProgram prog, size_t* logSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetProgramLog(nvrtcProgram prog, char* log) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcAddNameExpression(nvrtcProgram prog, const char* name_expression) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetLoweredName(nvrtcProgram prog, const char* name_expression, const char** lowered_name) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetPCHHeapSize(size_t* ret) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcSetPCHHeapSize(size_t size) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetPCHCreateStatus(nvrtcProgram prog) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcGetPCHHeapSizeRequired(nvrtcProgram prog, size_t* size) except ?NVRTC_ERROR_INVALID_INPUT nogil
+
+cdef nvrtcResult nvrtcSetFlowCallback(nvrtcProgram prog, void* callback, void* payload) except ?NVRTC_ERROR_INVALID_INPUT nogil

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cynvrtc.pyx

@@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# This code was automatically generated with version 12.9.0. Do not modify it directly.
+cimport cuda.bindings._bindings.cynvrtc as cynvrtc
+
+cdef const char* nvrtcGetErrorString(nvrtcResult result) except ?NULL nogil:
+    return cynvrtc._nvrtcGetErrorString(result)
+
+cdef nvrtcResult nvrtcVersion(int* major, int* minor) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcVersion(major, minor)
+
+cdef nvrtcResult nvrtcGetNumSupportedArchs(int* numArchs) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetNumSupportedArchs(numArchs)
+
+cdef nvrtcResult nvrtcGetSupportedArchs(int* supportedArchs) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetSupportedArchs(supportedArchs)
+
+cdef nvrtcResult nvrtcCreateProgram(nvrtcProgram* prog, const char* src, const char* name, int numHeaders, const char** headers, const char** includeNames) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcCreateProgram(prog, src, name, numHeaders, headers, includeNames)
+
+cdef nvrtcResult nvrtcDestroyProgram(nvrtcProgram* prog) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcDestroyProgram(prog)
+
+cdef nvrtcResult nvrtcCompileProgram(nvrtcProgram prog, int numOptions, const char** options) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcCompileProgram(prog, numOptions, options)
+
+cdef nvrtcResult nvrtcGetPTXSize(nvrtcProgram prog, size_t* ptxSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetPTXSize(prog, ptxSizeRet)
+
+cdef nvrtcResult nvrtcGetPTX(nvrtcProgram prog, char* ptx) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetPTX(prog, ptx)
+
+cdef nvrtcResult nvrtcGetCUBINSize(nvrtcProgram prog, size_t* cubinSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetCUBINSize(prog, cubinSizeRet)
+
+cdef nvrtcResult nvrtcGetCUBIN(nvrtcProgram prog, char* cubin) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetCUBIN(prog, cubin)
+
+cdef nvrtcResult nvrtcGetNVVMSize(nvrtcProgram prog, size_t* nvvmSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetNVVMSize(prog, nvvmSizeRet)
+
+cdef nvrtcResult nvrtcGetNVVM(nvrtcProgram prog, char* nvvm) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetNVVM(prog, nvvm)
+
+cdef nvrtcResult nvrtcGetLTOIRSize(nvrtcProgram prog, size_t* LTOIRSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetLTOIRSize(prog, LTOIRSizeRet)
+
+cdef nvrtcResult nvrtcGetLTOIR(nvrtcProgram prog, char* LTOIR) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetLTOIR(prog, LTOIR)
+
+cdef nvrtcResult nvrtcGetOptiXIRSize(nvrtcProgram prog, size_t* optixirSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetOptiXIRSize(prog, optixirSizeRet)
+
+cdef nvrtcResult nvrtcGetOptiXIR(nvrtcProgram prog, char* optixir) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetOptiXIR(prog, optixir)
+
+cdef nvrtcResult nvrtcGetProgramLogSize(nvrtcProgram prog, size_t* logSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetProgramLogSize(prog, logSizeRet)
+
+cdef nvrtcResult nvrtcGetProgramLog(nvrtcProgram prog, char* log) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetProgramLog(prog, log)
+
+cdef nvrtcResult nvrtcAddNameExpression(nvrtcProgram prog, const char* name_expression) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcAddNameExpression(prog, name_expression)
+
+cdef nvrtcResult nvrtcGetLoweredName(nvrtcProgram prog, const char* name_expression, const char** lowered_name) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetLoweredName(prog, name_expression, lowered_name)
+
+cdef nvrtcResult nvrtcGetPCHHeapSize(size_t* ret) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetPCHHeapSize(ret)
+
+cdef nvrtcResult nvrtcSetPCHHeapSize(size_t size) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcSetPCHHeapSize(size)
+
+cdef nvrtcResult nvrtcGetPCHCreateStatus(nvrtcProgram prog) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetPCHCreateStatus(prog)
+
+cdef nvrtcResult nvrtcGetPCHHeapSizeRequired(nvrtcProgram prog, size_t* size) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcGetPCHHeapSizeRequired(prog, size)
+
+cdef nvrtcResult nvrtcSetFlowCallback(nvrtcProgram prog, void* callback, void* payload) except ?NVRTC_ERROR_INVALID_INPUT nogil:
+    return cynvrtc._nvrtcSetFlowCallback(prog, callback, payload)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cynvvm.pxd

@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.0.1 to 12.9.1. Do not modify it directly.
+
+
+###############################################################################
+# Types (structs, enums, ...)
+###############################################################################
+
+# enums
+ctypedef enum nvvmResult "nvvmResult":
+    NVVM_SUCCESS "NVVM_SUCCESS" = 0
+    NVVM_ERROR_OUT_OF_MEMORY "NVVM_ERROR_OUT_OF_MEMORY" = 1
+    NVVM_ERROR_PROGRAM_CREATION_FAILURE "NVVM_ERROR_PROGRAM_CREATION_FAILURE" = 2
+    NVVM_ERROR_IR_VERSION_MISMATCH "NVVM_ERROR_IR_VERSION_MISMATCH" = 3
+    NVVM_ERROR_INVALID_INPUT "NVVM_ERROR_INVALID_INPUT" = 4
+    NVVM_ERROR_INVALID_PROGRAM "NVVM_ERROR_INVALID_PROGRAM" = 5
+    NVVM_ERROR_INVALID_IR "NVVM_ERROR_INVALID_IR" = 6
+    NVVM_ERROR_INVALID_OPTION "NVVM_ERROR_INVALID_OPTION" = 7
+    NVVM_ERROR_NO_MODULE_IN_PROGRAM "NVVM_ERROR_NO_MODULE_IN_PROGRAM" = 8
+    NVVM_ERROR_COMPILATION "NVVM_ERROR_COMPILATION" = 9
+    NVVM_ERROR_CANCELLED "NVVM_ERROR_CANCELLED" = 10
+    _NVVMRESULT_INTERNAL_LOADING_ERROR "_NVVMRESULT_INTERNAL_LOADING_ERROR" = -42
+
+
+# types
+ctypedef void* nvvmProgram 'nvvmProgram'
+
+
+###############################################################################
+# Functions
+###############################################################################
+
+cdef const char* nvvmGetErrorString(nvvmResult result) except?NULL nogil
+cdef nvvmResult nvvmVersion(int* major, int* minor) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmIRVersion(int* majorIR, int* minorIR, int* majorDbg, int* minorDbg) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmCreateProgram(nvvmProgram* prog) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmDestroyProgram(nvvmProgram* prog) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmAddModuleToProgram(nvvmProgram prog, const char* buffer, size_t size, const char* name) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmLazyAddModuleToProgram(nvvmProgram prog, const char* buffer, size_t size, const char* name) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmCompileProgram(nvvmProgram prog, int numOptions, const char** options) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmVerifyProgram(nvvmProgram prog, int numOptions, const char** options) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmGetCompiledResultSize(nvvmProgram prog, size_t* bufferSizeRet) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmGetCompiledResult(nvvmProgram prog, char* buffer) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmGetProgramLogSize(nvvmProgram prog, size_t* bufferSizeRet) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil
+cdef nvvmResult nvvmGetProgramLog(nvvmProgram prog, char* buffer) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cyruntime.pxd

@@ -0,0 +1,1015 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# This code was automatically generated with version 12.9.0. Do not modify it directly.
+
+from libc.stdint cimport uint32_t, uint64_t
+
+include "cyruntime_types.pxi"
+
+ctypedef unsigned int GLenum
+
+ctypedef unsigned int GLuint
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLImageKHR
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLStreamKHR
+
+ctypedef unsigned int EGLint
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLSyncKHR
+
+ctypedef uint32_t VdpDevice
+
+ctypedef unsigned long long VdpGetProcAddress
+
+ctypedef uint32_t VdpVideoSurface
+
+ctypedef uint32_t VdpOutputSurface
+
+cdef enum cudaEglFrameType_enum:
+    cudaEglFrameTypeArray = 0
+    cudaEglFrameTypePitch = 1
+
+ctypedef cudaEglFrameType_enum cudaEglFrameType
+
+cdef enum cudaEglResourceLocationFlags_enum:
+    cudaEglResourceLocationSysmem = 0
+    cudaEglResourceLocationVidmem = 1
+
+ctypedef cudaEglResourceLocationFlags_enum cudaEglResourceLocationFlags
+
+cdef enum cudaEglColorFormat_enum:
+    cudaEglColorFormatYUV420Planar = 0
+    cudaEglColorFormatYUV420SemiPlanar = 1
+    cudaEglColorFormatYUV422Planar = 2
+    cudaEglColorFormatYUV422SemiPlanar = 3
+    cudaEglColorFormatARGB = 6
+    cudaEglColorFormatRGBA = 7
+    cudaEglColorFormatL = 8
+    cudaEglColorFormatR = 9
+    cudaEglColorFormatYUV444Planar = 10
+    cudaEglColorFormatYUV444SemiPlanar = 11
+    cudaEglColorFormatYUYV422 = 12
+    cudaEglColorFormatUYVY422 = 13
+    cudaEglColorFormatABGR = 14
+    cudaEglColorFormatBGRA = 15
+    cudaEglColorFormatA = 16
+    cudaEglColorFormatRG = 17
+    cudaEglColorFormatAYUV = 18
+    cudaEglColorFormatYVU444SemiPlanar = 19
+    cudaEglColorFormatYVU422SemiPlanar = 20
+    cudaEglColorFormatYVU420SemiPlanar = 21
+    cudaEglColorFormatY10V10U10_444SemiPlanar = 22
+    cudaEglColorFormatY10V10U10_420SemiPlanar = 23
+    cudaEglColorFormatY12V12U12_444SemiPlanar = 24
+    cudaEglColorFormatY12V12U12_420SemiPlanar = 25
+    cudaEglColorFormatVYUY_ER = 26
+    cudaEglColorFormatUYVY_ER = 27
+    cudaEglColorFormatYUYV_ER = 28
+    cudaEglColorFormatYVYU_ER = 29
+    cudaEglColorFormatYUVA_ER = 31
+    cudaEglColorFormatAYUV_ER = 32
+    cudaEglColorFormatYUV444Planar_ER = 33
+    cudaEglColorFormatYUV422Planar_ER = 34
+    cudaEglColorFormatYUV420Planar_ER = 35
+    cudaEglColorFormatYUV444SemiPlanar_ER = 36
+    cudaEglColorFormatYUV422SemiPlanar_ER = 37
+    cudaEglColorFormatYUV420SemiPlanar_ER = 38
+    cudaEglColorFormatYVU444Planar_ER = 39
+    cudaEglColorFormatYVU422Planar_ER = 40
+    cudaEglColorFormatYVU420Planar_ER = 41
+    cudaEglColorFormatYVU444SemiPlanar_ER = 42
+    cudaEglColorFormatYVU422SemiPlanar_ER = 43
+    cudaEglColorFormatYVU420SemiPlanar_ER = 44
+    cudaEglColorFormatBayerRGGB = 45
+    cudaEglColorFormatBayerBGGR = 46
+    cudaEglColorFormatBayerGRBG = 47
+    cudaEglColorFormatBayerGBRG = 48
+    cudaEglColorFormatBayer10RGGB = 49
+    cudaEglColorFormatBayer10BGGR = 50
+    cudaEglColorFormatBayer10GRBG = 51
+    cudaEglColorFormatBayer10GBRG = 52
+    cudaEglColorFormatBayer12RGGB = 53
+    cudaEglColorFormatBayer12BGGR = 54
+    cudaEglColorFormatBayer12GRBG = 55
+    cudaEglColorFormatBayer12GBRG = 56
+    cudaEglColorFormatBayer14RGGB = 57
+    cudaEglColorFormatBayer14BGGR = 58
+    cudaEglColorFormatBayer14GRBG = 59
+    cudaEglColorFormatBayer14GBRG = 60
+    cudaEglColorFormatBayer20RGGB = 61
+    cudaEglColorFormatBayer20BGGR = 62
+    cudaEglColorFormatBayer20GRBG = 63
+    cudaEglColorFormatBayer20GBRG = 64
+    cudaEglColorFormatYVU444Planar = 65
+    cudaEglColorFormatYVU422Planar = 66
+    cudaEglColorFormatYVU420Planar = 67
+    cudaEglColorFormatBayerIspRGGB = 68
+    cudaEglColorFormatBayerIspBGGR = 69
+    cudaEglColorFormatBayerIspGRBG = 70
+    cudaEglColorFormatBayerIspGBRG = 71
+    cudaEglColorFormatBayerBCCR = 72
+    cudaEglColorFormatBayerRCCB = 73
+    cudaEglColorFormatBayerCRBC = 74
+    cudaEglColorFormatBayerCBRC = 75
+    cudaEglColorFormatBayer10CCCC = 76
+    cudaEglColorFormatBayer12BCCR = 77
+    cudaEglColorFormatBayer12RCCB = 78
+    cudaEglColorFormatBayer12CRBC = 79
+    cudaEglColorFormatBayer12CBRC = 80
+    cudaEglColorFormatBayer12CCCC = 81
+    cudaEglColorFormatY = 82
+    cudaEglColorFormatYUV420SemiPlanar_2020 = 83
+    cudaEglColorFormatYVU420SemiPlanar_2020 = 84
+    cudaEglColorFormatYUV420Planar_2020 = 85
+    cudaEglColorFormatYVU420Planar_2020 = 86
+    cudaEglColorFormatYUV420SemiPlanar_709 = 87
+    cudaEglColorFormatYVU420SemiPlanar_709 = 88
+    cudaEglColorFormatYUV420Planar_709 = 89
+    cudaEglColorFormatYVU420Planar_709 = 90
+    cudaEglColorFormatY10V10U10_420SemiPlanar_709 = 91
+    cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = 92
+    cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = 93
+    cudaEglColorFormatY10V10U10_422SemiPlanar = 94
+    cudaEglColorFormatY10V10U10_422SemiPlanar_709 = 95
+    cudaEglColorFormatY_ER = 96
+    cudaEglColorFormatY_709_ER = 97
+    cudaEglColorFormatY10_ER = 98
+    cudaEglColorFormatY10_709_ER = 99
+    cudaEglColorFormatY12_ER = 100
+    cudaEglColorFormatY12_709_ER = 101
+    cudaEglColorFormatYUVA = 102
+    cudaEglColorFormatYVYU = 104
+    cudaEglColorFormatVYUY = 105
+    cudaEglColorFormatY10V10U10_420SemiPlanar_ER = 106
+    cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = 107
+    cudaEglColorFormatY10V10U10_444SemiPlanar_ER = 108
+    cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = 109
+    cudaEglColorFormatY12V12U12_420SemiPlanar_ER = 110
+    cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = 111
+    cudaEglColorFormatY12V12U12_444SemiPlanar_ER = 112
+    cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = 113
+    cudaEglColorFormatUYVY709 = 114
+    cudaEglColorFormatUYVY709_ER = 115
+    cudaEglColorFormatUYVY2020 = 116
+
+ctypedef cudaEglColorFormat_enum cudaEglColorFormat
+
+cdef struct cudaEglPlaneDesc_st:
+    unsigned int width
+    unsigned int height
+    unsigned int depth
+    unsigned int pitch
+    unsigned int numChannels
+    cudaChannelFormatDesc channelDesc
+    unsigned int reserved[4]
+
+ctypedef cudaEglPlaneDesc_st cudaEglPlaneDesc
+
+cdef union anon_union11:
+    cudaArray_t pArray[3]
+    cudaPitchedPtr pPitch[3]
+
+cdef struct cudaEglFrame_st:
+    anon_union11 frame
+    cudaEglPlaneDesc planeDesc[3]
+    unsigned int planeCount
+    cudaEglFrameType frameType
+    cudaEglColorFormat eglColorFormat
+
+ctypedef cudaEglFrame_st cudaEglFrame
+
+cdef extern from "":
+    cdef struct CUeglStreamConnection_st:
+        pass
+ctypedef CUeglStreamConnection_st* cudaEglStreamConnection
+
+cdef enum cudaGLDeviceList:
+    cudaGLDeviceListAll = 1
+    cudaGLDeviceListCurrentFrame = 2
+    cudaGLDeviceListNextFrame = 3
+
+cdef enum cudaGLMapFlags:
+    cudaGLMapFlagsNone = 0
+    cudaGLMapFlagsReadOnly = 1
+    cudaGLMapFlagsWriteDiscard = 2
+
+cdef cudaError_t cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef const char* cudaGetErrorName(cudaError_t error) except ?NULL nogil
+
+cdef const char* cudaGetErrorString(cudaError_t error) except ?NULL nogil
+
+cdef cudaError_t cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil
+
+cdef cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil
+
+cdef cudaPos make_cudaPos(size_t x, size_t y, size_t z) except* nogil
+
+cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) except* nogil
+
+cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef cudaError_t getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil
+
+cdef enum: cudaHostAllocDefault = 0
+
+cdef enum: cudaHostAllocPortable = 1
+
+cdef enum: cudaHostAllocMapped = 2
+
+cdef enum: cudaHostAllocWriteCombined = 4
+
+cdef enum: cudaHostRegisterDefault = 0
+
+cdef enum: cudaHostRegisterPortable = 1
+
+cdef enum: cudaHostRegisterMapped = 2
+
+cdef enum: cudaHostRegisterIoMemory = 4
+
+cdef enum: cudaHostRegisterReadOnly = 8
+
+cdef enum: cudaPeerAccessDefault = 0
+
+cdef enum: cudaStreamDefault = 0
+
+cdef enum: cudaStreamNonBlocking = 1
+
+cdef enum: cudaStreamLegacy = 1
+
+cdef enum: cudaStreamPerThread = 2
+
+cdef enum: cudaEventDefault = 0
+
+cdef enum: cudaEventBlockingSync = 1
+
+cdef enum: cudaEventDisableTiming = 2
+
+cdef enum: cudaEventInterprocess = 4
+
+cdef enum: cudaEventRecordDefault = 0
+
+cdef enum: cudaEventRecordExternal = 1
+
+cdef enum: cudaEventWaitDefault = 0
+
+cdef enum: cudaEventWaitExternal = 1
+
+cdef enum: cudaDeviceScheduleAuto = 0
+
+cdef enum: cudaDeviceScheduleSpin = 1
+
+cdef enum: cudaDeviceScheduleYield = 2
+
+cdef enum: cudaDeviceScheduleBlockingSync = 4
+
+cdef enum: cudaDeviceBlockingSync = 4
+
+cdef enum: cudaDeviceScheduleMask = 7
+
+cdef enum: cudaDeviceMapHost = 8
+
+cdef enum: cudaDeviceLmemResizeToMax = 16
+
+cdef enum: cudaDeviceSyncMemops = 128
+
+cdef enum: cudaDeviceMask = 255
+
+cdef enum: cudaArrayDefault = 0
+
+cdef enum: cudaArrayLayered = 1
+
+cdef enum: cudaArraySurfaceLoadStore = 2
+
+cdef enum: cudaArrayCubemap = 4
+
+cdef enum: cudaArrayTextureGather = 8
+
+cdef enum: cudaArrayColorAttachment = 32
+
+cdef enum: cudaArraySparse = 64
+
+cdef enum: cudaArrayDeferredMapping = 128
+
+cdef enum: cudaIpcMemLazyEnablePeerAccess = 1
+
+cdef enum: cudaMemAttachGlobal = 1
+
+cdef enum: cudaMemAttachHost = 2
+
+cdef enum: cudaMemAttachSingle = 4
+
+cdef enum: cudaOccupancyDefault = 0
+
+cdef enum: cudaOccupancyDisableCachingOverride = 1
+
+cdef enum: cudaCpuDeviceId = -1
+
+cdef enum: cudaInvalidDeviceId = -2
+
+cdef enum: cudaInitDeviceFlagsAreValid = 1
+
+cdef enum: cudaCooperativeLaunchMultiDeviceNoPreSync = 1
+
+cdef enum: cudaCooperativeLaunchMultiDeviceNoPostSync = 2
+
+cdef enum: cudaArraySparsePropertiesSingleMipTail = 1
+
+cdef enum: cudaMemPoolCreateUsageHwDecompress = 2
+
+cdef enum: CUDA_IPC_HANDLE_SIZE = 64
+
+cdef enum: cudaExternalMemoryDedicated = 1
+
+cdef enum: cudaExternalSemaphoreSignalSkipNvSciBufMemSync = 1
+
+cdef enum: cudaExternalSemaphoreWaitSkipNvSciBufMemSync = 2
+
+cdef enum: cudaNvSciSyncAttrSignal = 1
+
+cdef enum: cudaNvSciSyncAttrWait = 2
+
+cdef enum: cudaGraphKernelNodePortDefault = 0
+
+cdef enum: cudaGraphKernelNodePortProgrammatic = 1
+
+cdef enum: cudaGraphKernelNodePortLaunchCompletion = 2
+
+cdef enum: cudaStreamAttributeAccessPolicyWindow = 1
+
+cdef enum: cudaStreamAttributeSynchronizationPolicy = 3
+
+cdef enum: cudaStreamAttributeMemSyncDomainMap = 9
+
+cdef enum: cudaStreamAttributeMemSyncDomain = 10
+
+cdef enum: cudaStreamAttributePriority = 8
+
+cdef enum: cudaKernelNodeAttributeAccessPolicyWindow = 1
+
+cdef enum: cudaKernelNodeAttributeCooperative = 2
+
+cdef enum: cudaKernelNodeAttributePriority = 8
+
+cdef enum: cudaKernelNodeAttributeClusterDimension = 4
+
+cdef enum: cudaKernelNodeAttributeClusterSchedulingPolicyPreference = 5
+
+cdef enum: cudaKernelNodeAttributeMemSyncDomainMap = 9
+
+cdef enum: cudaKernelNodeAttributeMemSyncDomain = 10
+
+cdef enum: cudaKernelNodeAttributePreferredSharedMemoryCarveout = 14
+
+cdef enum: cudaKernelNodeAttributeDeviceUpdatableKernelNode = 13
+
+cdef enum: cudaSurfaceType1D = 1
+
+cdef enum: cudaSurfaceType2D = 2
+
+cdef enum: cudaSurfaceType3D = 3
+
+cdef enum: cudaSurfaceTypeCubemap = 12
+
+cdef enum: cudaSurfaceType1DLayered = 241
+
+cdef enum: cudaSurfaceType2DLayered = 242
+
+cdef enum: cudaSurfaceTypeCubemapLayered = 252
+
+cdef enum: cudaTextureType1D = 1
+
+cdef enum: cudaTextureType2D = 2
+
+cdef enum: cudaTextureType3D = 3
+
+cdef enum: cudaTextureTypeCubemap = 12
+
+cdef enum: cudaTextureType1DLayered = 241
+
+cdef enum: cudaTextureType2DLayered = 242
+
+cdef enum: cudaTextureTypeCubemapLayered = 252
+
+cdef enum: CUDART_VERSION = 12090
+
+cdef enum: __CUDART_API_VERSION = 12090
+
+cdef enum: CUDA_EGL_MAX_PLANES = 3

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cyruntime.pyx

@@ -0,0 +1,974 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# This code was automatically generated with version 12.9.0. Do not modify it directly.
+cimport cuda.bindings._bindings.cyruntime as cyruntime
+cimport cython
+
+cdef cudaError_t cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceReset()
+
+cdef cudaError_t cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceSynchronize()
+
+cdef cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceSetLimit(limit, value)
+
+cdef cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetLimit(pValue, limit)
+
+cdef cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device)
+
+cdef cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetCacheConfig(pCacheConfig)
+
+cdef cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority)
+
+cdef cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceSetCacheConfig(cacheConfig)
+
+cdef cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetByPCIBusId(device, pciBusId)
+
+cdef cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetPCIBusId(pciBusId, length, device)
+
+cdef cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaIpcGetEventHandle(handle, event)
+
+cdef cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaIpcOpenEventHandle(event, handle)
+
+cdef cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaIpcGetMemHandle(handle, devPtr)
+
+cdef cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaIpcOpenMemHandle(devPtr, handle, flags)
+
+cdef cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaIpcCloseMemHandle(devPtr)
+
+cdef cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceFlushGPUDirectRDMAWrites(target, scope)
+
+cdef cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback)
+
+cdef cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceUnregisterAsyncNotification(device, callback)
+
+cdef cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetSharedMemConfig(pConfig)
+
+cdef cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceSetSharedMemConfig(config)
+
+cdef cudaError_t cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetLastError()
+
+cdef cudaError_t cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaPeekAtLastError()
+
+cdef const char* cudaGetErrorName(cudaError_t error) except ?NULL nogil:
+    return cyruntime._cudaGetErrorName(error)
+
+cdef const char* cudaGetErrorString(cudaError_t error) except ?NULL nogil:
+    return cyruntime._cudaGetErrorString(error)
+
+cdef cudaError_t cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetDeviceCount(count)
+
+cdef cudaError_t cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetDeviceProperties_v2(prop, device)
+
+cdef cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetAttribute(value, attr, device)
+
+cdef cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetDefaultMemPool(memPool, device)
+
+cdef cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceSetMemPool(device, memPool)
+
+cdef cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetMemPool(memPool, device)
+
+cdef cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags)
+
+cdef cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice)
+
+cdef cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaChooseDevice(device, prop)
+
+cdef cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaInitDevice(device, deviceFlags, flags)
+
+cdef cudaError_t cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaSetDevice(device)
+
+cdef cudaError_t cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetDevice(device)
+
+cdef cudaError_t cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaSetDeviceFlags(flags)
+
+cdef cudaError_t cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetDeviceFlags(flags)
+
+cdef cudaError_t cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamCreate(pStream)
+
+cdef cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamCreateWithFlags(pStream, flags)
+
+cdef cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamCreateWithPriority(pStream, flags, priority)
+
+cdef cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamGetPriority(hStream, priority)
+
+cdef cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamGetFlags(hStream, flags)
+
+cdef cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamGetId(hStream, streamId)
+
+cdef cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamGetDevice(hStream, device)
+
+cdef cudaError_t cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaCtxResetPersistingL2Cache()
+
+cdef cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamCopyAttributes(dst, src)
+
+cdef cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamGetAttribute(hStream, attr, value_out)
+
+cdef cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamSetAttribute(hStream, attr, value)
+
+cdef cudaError_t cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamDestroy(stream)
+
+cdef cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamWaitEvent(stream, event, flags)
+
+cdef cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamAddCallback(stream, callback, userData, flags)
+
+cdef cudaError_t cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamSynchronize(stream)
+
+cdef cudaError_t cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamQuery(stream)
+
+cdef cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamAttachMemAsync(stream, devPtr, length, flags)
+
+cdef cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamBeginCapture(stream, mode)
+
+cdef cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode)
+
+cdef cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaThreadExchangeStreamCaptureMode(mode)
+
+cdef cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamEndCapture(stream, pGraph)
+
+cdef cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamIsCapturing(stream, pCaptureStatus)
+
+cdef cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamGetCaptureInfo_v2(stream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out)
+
+cdef cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamGetCaptureInfo_v3(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out)
+
+cdef cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamUpdateCaptureDependencies(stream, dependencies, numDependencies, flags)
+
+cdef cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaStreamUpdateCaptureDependencies_v2(stream, dependencies, dependencyData, numDependencies, flags)
+
+cdef cudaError_t cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventCreate(event)
+
+cdef cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventCreateWithFlags(event, flags)
+
+cdef cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventRecord(event, stream)
+
+cdef cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventRecordWithFlags(event, stream, flags)
+
+cdef cudaError_t cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventQuery(event)
+
+cdef cudaError_t cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventSynchronize(event)
+
+cdef cudaError_t cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventDestroy(event)
+
+cdef cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventElapsedTime(ms, start, end)
+
+cdef cudaError_t cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventElapsedTime_v2(ms, start, end)
+
+cdef cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaImportExternalMemory(extMem_out, memHandleDesc)
+
+cdef cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc)
+
+cdef cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc)
+
+cdef cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDestroyExternalMemory(extMem)
+
+cdef cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaImportExternalSemaphore(extSem_out, semHandleDesc)
+
+cdef cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaSignalExternalSemaphoresAsync_v2(extSemArray, paramsArray, numExtSems, stream)
+
+cdef cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaWaitExternalSemaphoresAsync_v2(extSemArray, paramsArray, numExtSems, stream)
+
+cdef cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDestroyExternalSemaphore(extSem)
+
+cdef cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFuncSetCacheConfig(func, cacheConfig)
+
+cdef cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFuncGetAttributes(attr, func)
+
+cdef cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFuncSetAttribute(func, attr, value)
+
+cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLaunchHostFunc(stream, fn, userData)
+
+cdef cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFuncSetSharedMemConfig(func, config)
+
+cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize)
+
+cdef cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize)
+
+cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags)
+
+cdef cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMallocManaged(devPtr, size, flags)
+
+cdef cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMalloc(devPtr, size)
+
+cdef cudaError_t cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMallocHost(ptr, size)
+
+cdef cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMallocPitch(devPtr, pitch, width, height)
+
+cdef cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMallocArray(array, desc, width, height, flags)
+
+cdef cudaError_t cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFree(devPtr)
+
+cdef cudaError_t cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFreeHost(ptr)
+
+cdef cudaError_t cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFreeArray(array)
+
+cdef cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFreeMipmappedArray(mipmappedArray)
+
+cdef cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaHostAlloc(pHost, size, flags)
+
+cdef cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaHostRegister(ptr, size, flags)
+
+cdef cudaError_t cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaHostUnregister(ptr)
+
+cdef cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaHostGetDevicePointer(pDevice, pHost, flags)
+
+cdef cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaHostGetFlags(pFlags, pHost)
+
+cdef cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMalloc3D(pitchedDevPtr, extent)
+
+cdef cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMalloc3DArray(array, desc, extent, flags)
+
+cdef cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags)
+
+cdef cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level)
+
+cdef cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy3D(p)
+
+cdef cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy3DPeer(p)
+
+cdef cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy3DAsync(p, stream)
+
+cdef cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy3DPeerAsync(p, stream)
+
+cdef cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemGetInfo(free, total)
+
+cdef cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaArrayGetInfo(desc, extent, flags, array)
+
+cdef cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaArrayGetPlane(pPlaneArray, hArray, planeIdx)
+
+cdef cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaArrayGetMemoryRequirements(memoryRequirements, array, device)
+
+cdef cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device)
+
+cdef cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaArrayGetSparseProperties(sparseProperties, array)
+
+cdef cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap)
+
+cdef cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy(dst, src, count, kind)
+
+cdef cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count)
+
+cdef cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind)
+
+cdef cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind)
+
+cdef cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind)
+
+cdef cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind)
+
+cdef cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyAsync(dst, src, count, kind, stream)
+
+cdef cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream)
+
+cdef cudaError_t cudaMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, stream)
+
+cdef cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy3DBatchAsync(numOps, opList, failIdx, flags, stream)
+
+cdef cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream)
+
+cdef cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream)
+
+cdef cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream)
+
+cdef cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemset(devPtr, value, count)
+
+cdef cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemset2D(devPtr, pitch, value, width, height)
+
+cdef cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemset3D(pitchedDevPtr, value, extent)
+
+cdef cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemsetAsync(devPtr, value, count, stream)
+
+cdef cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemset2DAsync(devPtr, pitch, value, width, height, stream)
+
+cdef cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemset3DAsync(pitchedDevPtr, value, extent, stream)
+
+cdef cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPrefetchAsync(devPtr, count, dstDevice, stream)
+
+cdef cudaError_t cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPrefetchAsync_v2(devPtr, count, location, flags, stream)
+
+cdef cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemAdvise(devPtr, count, advice, device)
+
+cdef cudaError_t cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemAdvise_v2(devPtr, count, advice, location)
+
+cdef cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count)
+
+cdef cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count)
+
+cdef cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind)
+
+cdef cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind)
+
+cdef cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind)
+
+cdef cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream)
+
+cdef cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream)
+
+cdef cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMallocAsync(devPtr, size, hStream)
+
+cdef cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaFreeAsync(devPtr, hStream)
+
+cdef cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolTrimTo(memPool, minBytesToKeep)
+
+cdef cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolSetAttribute(memPool, attr, value)
+
+cdef cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolGetAttribute(memPool, attr, value)
+
+cdef cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolSetAccess(memPool, descList, count)
+
+cdef cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolGetAccess(flags, memPool, location)
+
+cdef cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolCreate(memPool, poolProps)
+
+cdef cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolDestroy(memPool)
+
+cdef cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMallocFromPoolAsync(ptr, size, memPool, stream)
+
+cdef cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags)
+
+cdef cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags)
+
+cdef cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolExportPointer(exportData, ptr)
+
+cdef cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaMemPoolImportPointer(ptr, memPool, exportData)
+
+cdef cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaPointerGetAttributes(attributes, ptr)
+
+cdef cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice)
+
+cdef cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceEnablePeerAccess(peerDevice, flags)
+
+cdef cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceDisablePeerAccess(peerDevice)
+
+cdef cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsUnregisterResource(resource)
+
+cdef cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsResourceSetMapFlags(resource, flags)
+
+cdef cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsMapResources(count, resources, stream)
+
+cdef cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsUnmapResources(count, resources, stream)
+
+cdef cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsResourceGetMappedPointer(devPtr, size, resource)
+
+cdef cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel)
+
+cdef cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource)
+
+cdef cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetChannelDesc(desc, array)
+@cython.show_performance_hints(False)
+cdef cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil:
+    return cyruntime._cudaCreateChannelDesc(x, y, z, w, f)
+
+cdef cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc)
+
+cdef cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDestroyTextureObject(texObject)
+
+cdef cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetTextureObjectResourceDesc(pResDesc, texObject)
+
+cdef cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetTextureObjectTextureDesc(pTexDesc, texObject)
+
+cdef cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject)
+
+cdef cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaCreateSurfaceObject(pSurfObject, pResDesc)
+
+cdef cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDestroySurfaceObject(surfObject)
+
+cdef cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject)
+
+cdef cudaError_t cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDriverGetVersion(driverVersion)
+
+cdef cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaRuntimeGetVersion(runtimeVersion)
+
+cdef cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphCreate(pGraph, flags)
+
+cdef cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)
+
+cdef cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphKernelNodeGetParams(node, pNodeParams)
+
+cdef cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphKernelNodeSetParams(node, pNodeParams)
+
+cdef cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphKernelNodeCopyAttributes(hSrc, hDst)
+
+cdef cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphKernelNodeGetAttribute(hNode, attr, value_out)
+
+cdef cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphKernelNodeSetAttribute(hNode, attr, value)
+
+cdef cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams)
+
+cdef cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind)
+
+cdef cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphMemcpyNodeGetParams(node, pNodeParams)
+
+cdef cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphMemcpyNodeSetParams(node, pNodeParams)
+
+cdef cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind)
+
+cdef cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams)
+
+cdef cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphMemsetNodeGetParams(node, pNodeParams)
+
+cdef cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphMemsetNodeSetParams(node, pNodeParams)
+
+cdef cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)
+
+cdef cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphHostNodeGetParams(node, pNodeParams)
+
+cdef cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphHostNodeSetParams(node, pNodeParams)
+
+cdef cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph)
+
+cdef cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphChildGraphNodeGetGraph(node, pGraph)
+
+cdef cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies)
+
+cdef cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event)
+
+cdef cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphEventRecordNodeGetEvent(node, event_out)
+
+cdef cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphEventRecordNodeSetEvent(node, event)
+
+cdef cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event)
+
+cdef cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphEventWaitNodeGetEvent(node, event_out)
+
+cdef cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphEventWaitNodeSetEvent(node, event)
+
+cdef cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
+
+cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out)
+
+cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams)
+
+cdef cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
+
+cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out)
+
+cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams)
+
+cdef cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
+
+cdef cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphMemAllocNodeGetParams(node, params_out)
+
+cdef cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr)
+
+cdef cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphMemFreeNodeGetParams(node, dptr_out)
+
+cdef cudaError_t cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGraphMemTrim(device)
+
+cdef cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceGetGraphMemAttribute(device, attr, value)
+
+cdef cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaDeviceSetGraphMemAttribute(device, attr, value)
+
+cdef cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphClone(pGraphClone, originalGraph)
+
+cdef cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph)
+
+cdef cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeGetType(node, pType)
+
+cdef cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphGetNodes(graph, nodes, numNodes)
+
+cdef cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes)
+
+cdef cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphGetEdges(graph, from_, to, numEdges)
+
+cdef cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphGetEdges_v2(graph, from_, to, edgeData, numEdges)
+
+cdef cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeGetDependencies(node, pDependencies, pNumDependencies)
+
+cdef cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeGetDependencies_v2(node, pDependencies, edgeData, pNumDependencies)
+
+cdef cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeGetDependentNodes(node, pDependentNodes, pNumDependentNodes)
+
+cdef cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeGetDependentNodes_v2(node, pDependentNodes, edgeData, pNumDependentNodes)
+
+cdef cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddDependencies(graph, from_, to, numDependencies)
+
+cdef cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddDependencies_v2(graph, from_, to, edgeData, numDependencies)
+
+cdef cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphRemoveDependencies(graph, from_, to, numDependencies)
+
+cdef cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphRemoveDependencies_v2(graph, from_, to, edgeData, numDependencies)
+
+cdef cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphDestroyNode(node)
+
+cdef cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphInstantiate(pGraphExec, graph, flags)
+
+cdef cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphInstantiateWithFlags(pGraphExec, graph, flags)
+
+cdef cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams)
+
+cdef cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecGetFlags(graphExec, flags)
+
+cdef cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams)
+
+cdef cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams)
+
+cdef cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind)
+
+cdef cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams)
+
+cdef cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams)
+
+cdef cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph)
+
+cdef cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event)
+
+cdef cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event)
+
+cdef cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams)
+
+cdef cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams)
+
+cdef cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled)
+
+cdef cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled)
+
+cdef cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo)
+
+cdef cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphUpload(graphExec, stream)
+
+cdef cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphLaunch(graphExec, stream)
+
+cdef cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecDestroy(graphExec)
+
+cdef cudaError_t cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphDestroy(graph)
+
+cdef cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphDebugDotPrint(graph, path, flags)
+
+cdef cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags)
+
+cdef cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaUserObjectRetain(object, count)
+
+cdef cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaUserObjectRelease(object, count)
+
+cdef cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphRetainUserObject(graph, object, count, flags)
+
+cdef cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphReleaseUserObject(graph, object, count)
+
+cdef cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
+
+cdef cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphAddNode_v2(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams)
+
+cdef cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphNodeSetParams(node, nodeParams)
+
+cdef cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphExecNodeSetParams(graphExec, node, nodeParams)
+
+cdef cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags)
+
+cdef cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus)
+
+cdef cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus)
+
+cdef cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions)
+
+cdef cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions)
+
+cdef cudaError_t cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryUnload(library)
+
+cdef cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryGetKernel(pKernel, library, name)
+
+cdef cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryGetGlobal(dptr, numbytes, library, name)
+
+cdef cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryGetManaged(dptr, numbytes, library, name)
+
+cdef cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryGetUnifiedFunction(fptr, library, symbol)
+
+cdef cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryGetKernelCount(count, lib)
+
+cdef cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaLibraryEnumerateKernels(kernels, numKernels, lib)
+
+cdef cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaKernelSetAttributeForDevice(kernel, attr, value, device)
+
+cdef cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetExportTable(ppExportTable, pExportTableId)
+
+cdef cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGetKernel(kernelPtr, entryFuncAddr)
+@cython.show_performance_hints(False)
+cdef cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil:
+    return cyruntime._make_cudaPitchedPtr(d, p, xsz, ysz)
+@cython.show_performance_hints(False)
+cdef cudaPos make_cudaPos(size_t x, size_t y, size_t z) except* nogil:
+    return cyruntime._make_cudaPos(x, y, z)
+@cython.show_performance_hints(False)
+cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) except* nogil:
+    return cyruntime._make_cudaExtent(w, h, d)
+
+cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsEGLRegisterImage(pCudaResource, image, flags)
+
+cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamConsumerConnect(conn, eglStream)
+
+cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamConsumerConnectWithFlags(conn, eglStream, flags)
+
+cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamConsumerDisconnect(conn)
+
+cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout)
+
+cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream)
+
+cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamProducerConnect(conn, eglStream, width, height)
+
+cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamProducerDisconnect(conn)
+
+cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamProducerPresentFrame(conn, eglframe, pStream)
+
+cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEGLStreamProducerReturnFrame(conn, eglframe, pStream)
+
+cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsResourceGetMappedEglFrame(eglFrame, resource, index, mipLevel)
+
+cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaEventCreateFromEGLSync(phEvent, eglSync, flags)
+
+cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaProfilerStart()
+
+cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaProfilerStop()
+
+cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGLGetDevices(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList)
+
+cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsGLRegisterImage(resource, image, target, flags)
+
+cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsGLRegisterBuffer(resource, buffer, flags)
+
+cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaVDPAUGetDevice(device, vdpDevice, vdpGetProcAddress)
+
+cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaVDPAUSetVDPAUDevice(device, vdpDevice, vdpGetProcAddress)
+
+cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsVDPAURegisterVideoSurface(resource, vdpSurface, flags)
+
+cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cyruntime._cudaGraphicsVDPAURegisterOutputSurface(resource, vdpSurface, flags)
+
+from libc.stdint cimport uintptr_t
+from cuda.pathfinder import load_nvidia_dynamic_lib
+cimport cuda.bindings._lib.dlfcn as dlfcn
+
+cdef cudaError_t getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
+    # Load
+    with gil:
+        loaded_dl = load_nvidia_dynamic_lib("cudart")
+        handle = <void *><uintptr_t>loaded_dl._handle_uint
+    __cudaRuntimeGetVersion = dlfcn.dlsym(handle, 'cudaRuntimeGetVersion')
+
+    if __cudaRuntimeGetVersion == NULL:
+        with gil:
+            raise RuntimeError(f'Function "cudaRuntimeGetVersion" not found in {loaded_dl.abs_path}')
+
+    # Call
+    cdef cudaError_t err = cudaSuccess
+    err = (<cudaError_t (*)(int*) except ?cudaErrorCallRequiresNewerDriver nogil> __cudaRuntimeGetVersion)(runtimeVersion)
+
+    # We explicitly do *NOT* cleanup the library handle here, acknowledging
+    # that, yes, the handle leaks. The reason is that there's a
+    # `functools.cache` on the top-level caller of this function.
+    #
+    # This means this library would be opened once and then immediately closed,
+    # all the while remaining in the cache lurking there for people to call.
+    #
+    # Since we open the library one time (technically once per unique library name),
+    # there's not a ton of leakage, which we deem acceptable for the 1000x speedup
+    # achieved by caching (ultimately) `ctypes.CDLL` calls.
+    #
+    # Long(er)-term we can explore cleaning up the library using higher-level
+    # Python mechanisms, like `__del__` or `weakref.finalizer`s.
+
+    return err

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cyruntime_functions.pxi

@@ -0,0 +1,897 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# This code was automatically generated with version 12.9.0. Do not modify it directly.
+cdef extern from "cuda_runtime_api.h":
+
+
+    cudaError_t cudaDeviceReset() nogil
+
+
+    cudaError_t cudaDeviceSynchronize() nogil
+
+
+    cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) nogil
+
+
+    cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) nogil
+
+
+    cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) nogil
+
+
+    cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) nogil
+
+
+    cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) nogil
+
+
+    cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) nogil
+
+
+    cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) nogil
+
+
+    cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) nogil
+
+
+    cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) nogil
+
+
+    cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) nogil
+
+
+    cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) nogil
+
+
+    cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) nogil
+
+
+    cudaError_t cudaIpcCloseMemHandle(void* devPtr) nogil
+
+
+    cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) nogil
+
+
+    cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) nogil
+
+
+    cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) nogil
+
+
+    cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) nogil
+
+
+    cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) nogil
+
+
+    cudaError_t cudaGetLastError() nogil
+
+
+    cudaError_t cudaPeekAtLastError() nogil
+
+
+    const char* cudaGetErrorName(cudaError_t error) nogil
+
+
+    const char* cudaGetErrorString(cudaError_t error) nogil
+
+
+    cudaError_t cudaGetDeviceCount(int* count) nogil
+
+
+    cudaError_t cudaGetDeviceProperties_v2(cudaDeviceProp* prop, int device) nogil
+
+
+    cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) nogil
+
+
+    cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) nogil
+
+
+    cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) nogil
+
+
+    cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) nogil
+
+
+    cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) nogil
+
+
+    cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) nogil
+
+
+    cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) nogil
+
+
+    cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) nogil
+
+
+    cudaError_t cudaSetDevice(int device) nogil
+
+
+    cudaError_t cudaGetDevice(int* device) nogil
+
+
+    cudaError_t cudaSetDeviceFlags(unsigned int flags) nogil
+
+
+    cudaError_t cudaGetDeviceFlags(unsigned int* flags) nogil
+
+
+    cudaError_t cudaStreamCreate(cudaStream_t* pStream) nogil
+
+
+    cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) nogil
+
+
+    cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) nogil
+
+
+    cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) nogil
+
+
+    cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) nogil
+
+
+    cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) nogil
+
+
+    cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) nogil
+
+
+    cudaError_t cudaCtxResetPersistingL2Cache() nogil
+
+
+    cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) nogil
+
+
+    cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) nogil
+
+
+    cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) nogil
+
+
+    cudaError_t cudaStreamDestroy(cudaStream_t stream) nogil
+
+
+    cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) nogil
+
+
+    cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) nogil
+
+
+    cudaError_t cudaStreamSynchronize(cudaStream_t stream) nogil
+
+
+    cudaError_t cudaStreamQuery(cudaStream_t stream) nogil
+
+
+    cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) nogil
+
+
+    cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) nogil
+
+
+    cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) nogil
+
+
+    cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) nogil
+
+
+    cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) nogil
+
+
+    cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) nogil
+
+
+    cudaError_t cudaStreamGetCaptureInfo_v2_ptsz(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) nogil
+
+
+    cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) nogil
+
+
+    cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) nogil
+
+
+    cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) nogil
+
+
+    cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) nogil
+
+
+    cudaError_t cudaEventCreate(cudaEvent_t* event) nogil
+
+
+    cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) nogil
+
+
+    cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) nogil
+
+
+    cudaError_t cudaEventQuery(cudaEvent_t event) nogil
+
+
+    cudaError_t cudaEventSynchronize(cudaEvent_t event) nogil
+
+
+    cudaError_t cudaEventDestroy(cudaEvent_t event) nogil
+
+
+    cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) nogil
+
+
+    cudaError_t cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) nogil
+
+
+    cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) nogil
+
+
+    cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) nogil
+
+
+    cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) nogil
+
+
+    cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) nogil
+
+
+    cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) nogil
+
+
+    cudaError_t cudaSignalExternalSemaphoresAsync_v2_ptsz(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaWaitExternalSemaphoresAsync_v2_ptsz(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) nogil
+
+
+    cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) nogil
+
+
+    cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) nogil
+
+
+    cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) nogil
+
+
+    cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) nogil
+
+
+    cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) nogil
+
+
+    cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) nogil
+
+
+    cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) nogil
+
+
+    cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) nogil
+
+
+    cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) nogil
+
+
+    cudaError_t cudaMalloc(void** devPtr, size_t size) nogil
+
+
+    cudaError_t cudaMallocHost(void** ptr, size_t size) nogil
+
+
+    cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) nogil
+
+
+    cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) nogil
+
+
+    cudaError_t cudaFree(void* devPtr) nogil
+
+
+    cudaError_t cudaFreeHost(void* ptr) nogil
+
+
+    cudaError_t cudaFreeArray(cudaArray_t array) nogil
+
+
+    cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) nogil
+
+
+    cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) nogil
+
+
+    cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) nogil
+
+
+    cudaError_t cudaHostUnregister(void* ptr) nogil
+
+
+    cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) nogil
+
+
+    cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) nogil
+
+
+    cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) nogil
+
+
+    cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) nogil
+
+
+    cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) nogil
+
+
+    cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) nogil
+
+
+    cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) nogil
+
+
+    cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) nogil
+
+
+    cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemGetInfo(size_t* free, size_t* total) nogil
+
+
+    cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) nogil
+
+
+    cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) nogil
+
+
+    cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) nogil
+
+
+    cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) nogil
+
+
+    cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) nogil
+
+
+    cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) nogil
+
+
+    cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) nogil
+
+
+    cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemset(void* devPtr, int value, size_t count) nogil
+
+
+    cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) nogil
+
+
+    cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) nogil
+
+
+    cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) nogil
+
+
+    cudaError_t cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) nogil
+
+
+    cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) nogil
+
+
+    cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) nogil
+
+
+    cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) nogil
+
+
+    cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) nogil
+
+
+    cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) nogil
+
+
+    cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) nogil
+
+
+    cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) nogil
+
+
+    cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) nogil
+
+
+    cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) nogil
+
+
+    cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) nogil
+
+
+    cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) nogil
+
+
+    cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) nogil
+
+
+    cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) nogil
+
+
+    cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) nogil
+
+
+    cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) nogil
+
+
+    cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) nogil
+
+
+    cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) nogil
+
+
+    cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) nogil
+
+
+    cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) nogil
+
+
+    cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) nogil
+
+
+    cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) nogil
+
+
+    cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) nogil
+
+
+    cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) nogil
+
+
+    cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) nogil
+
+
+    cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) nogil
+
+
+    cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) nogil
+
+
+    cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) nogil
+
+
+    cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) nogil
+
+
+    cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) nogil
+
+
+    cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) nogil
+
+
+    cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) nogil
+
+
+    cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) nogil
+
+
+    cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) nogil
+
+
+    cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) nogil
+
+
+    cudaError_t cudaDriverGetVersion(int* driverVersion) nogil
+
+
+    cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) nogil
+
+
+    cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) nogil
+
+
+    cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) nogil
+
+
+    cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) nogil
+
+
+    cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) nogil
+
+
+    cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) nogil
+
+
+    cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) nogil
+
+
+    cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) nogil
+
+
+    cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) nogil
+
+
+    cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) nogil
+
+
+    cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) nogil
+
+
+    cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) nogil
+
+
+    cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) nogil
+
+
+    cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) nogil
+
+
+    cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) nogil
+
+
+    cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) nogil
+
+
+    cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) nogil
+
+
+    cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) nogil
+
+
+    cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) nogil
+
+
+    cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) nogil
+
+
+    cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) nogil
+
+
+    cudaError_t cudaDeviceGraphMemTrim(int device) nogil
+
+
+    cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) nogil
+
+
+    cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) nogil
+
+
+    cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) nogil
+
+
+    cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) nogil
+
+
+    cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) nogil
+
+
+    cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) nogil
+
+
+    cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) nogil
+
+
+    cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) nogil
+
+
+    cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) nogil
+
+
+    cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) nogil
+
+
+    cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) nogil
+
+
+    cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) nogil
+
+
+    cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) nogil
+
+
+    cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) nogil
+
+
+    cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) nogil
+
+
+    cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) nogil
+
+
+    cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) nogil
+
+
+    cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) nogil
+
+
+    cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) nogil
+
+
+    cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) nogil
+
+
+    cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) nogil
+
+
+    cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) nogil
+
+
+    cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil
+
+
+    cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) nogil
+
+
+    cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) nogil
+
+
+    cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) nogil
+
+
+    cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) nogil
+
+
+    cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) nogil
+
+
+    cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) nogil
+
+
+    cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) nogil
+
+
+    cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) nogil
+
+
+    cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) nogil
+
+
+    cudaError_t cudaGraphDestroy(cudaGraph_t graph) nogil
+
+
+    cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) nogil
+
+
+    cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) nogil
+
+
+    cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) nogil
+
+
+    cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) nogil
+
+
+    cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) nogil
+
+
+    cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) nogil
+
+
+    cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) nogil
+
+
+    cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) nogil
+
+
+    cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) nogil
+
+
+    cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) nogil
+
+
+    cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) nogil
+
+
+    cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) nogil
+
+
+    cudaError_t cudaLibraryUnload(cudaLibrary_t library) nogil
+
+
+    cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) nogil
+
+
+    cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) nogil
+
+
+    cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) nogil
+
+
+    cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) nogil
+
+
+    cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) nogil
+
+
+    cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) nogil
+
+
+    cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) nogil
+
+
+    cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) nogil
+
+
+    cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) nogil
+
+
+cdef extern from "cuda_runtime.h":
+
+
+    cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) nogil
+
+
+    cudaPos make_cudaPos(size_t x, size_t y, size_t z) nogil
+
+
+    cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) nogil
+
+
+cdef extern from "cuda_profiler_api.h":
+
+
+    cudaError_t cudaProfilerStart() nogil
+
+
+    cudaError_t cudaProfilerStop() nogil
+

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/cyruntime_types.pxi

@@ -0,0 +1,1559 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# This code was automatically generated with version 12.9.0. Do not modify it directly.
+
+cdef extern from "vector_types.h":
+
+    cdef struct dim3:
+        unsigned int x
+        unsigned int y
+        unsigned int z
+
+cdef extern from "driver_types.h":
+
+    cdef enum cudaError:
+        cudaSuccess = 0
+        cudaErrorInvalidValue = 1
+        cudaErrorMemoryAllocation = 2
+        cudaErrorInitializationError = 3
+        cudaErrorCudartUnloading = 4
+        cudaErrorProfilerDisabled = 5
+        cudaErrorProfilerNotInitialized = 6
+        cudaErrorProfilerAlreadyStarted = 7
+        cudaErrorProfilerAlreadyStopped = 8
+        cudaErrorInvalidConfiguration = 9
+        cudaErrorInvalidPitchValue = 12
+        cudaErrorInvalidSymbol = 13
+        cudaErrorInvalidHostPointer = 16
+        cudaErrorInvalidDevicePointer = 17
+        cudaErrorInvalidTexture = 18
+        cudaErrorInvalidTextureBinding = 19
+        cudaErrorInvalidChannelDescriptor = 20
+        cudaErrorInvalidMemcpyDirection = 21
+        cudaErrorAddressOfConstant = 22
+        cudaErrorTextureFetchFailed = 23
+        cudaErrorTextureNotBound = 24
+        cudaErrorSynchronizationError = 25
+        cudaErrorInvalidFilterSetting = 26
+        cudaErrorInvalidNormSetting = 27
+        cudaErrorMixedDeviceExecution = 28
+        cudaErrorNotYetImplemented = 31
+        cudaErrorMemoryValueTooLarge = 32
+        cudaErrorStubLibrary = 34
+        cudaErrorInsufficientDriver = 35
+        cudaErrorCallRequiresNewerDriver = 36
+        cudaErrorInvalidSurface = 37
+        cudaErrorDuplicateVariableName = 43
+        cudaErrorDuplicateTextureName = 44
+        cudaErrorDuplicateSurfaceName = 45
+        cudaErrorDevicesUnavailable = 46
+        cudaErrorIncompatibleDriverContext = 49
+        cudaErrorMissingConfiguration = 52
+        cudaErrorPriorLaunchFailure = 53
+        cudaErrorLaunchMaxDepthExceeded = 65
+        cudaErrorLaunchFileScopedTex = 66
+        cudaErrorLaunchFileScopedSurf = 67
+        cudaErrorSyncDepthExceeded = 68
+        cudaErrorLaunchPendingCountExceeded = 69
+        cudaErrorInvalidDeviceFunction = 98
+        cudaErrorNoDevice = 100
+        cudaErrorInvalidDevice = 101
+        cudaErrorDeviceNotLicensed = 102
+        cudaErrorSoftwareValidityNotEstablished = 103
+        cudaErrorStartupFailure = 127
+        cudaErrorInvalidKernelImage = 200
+        cudaErrorDeviceUninitialized = 201
+        cudaErrorMapBufferObjectFailed = 205
+        cudaErrorUnmapBufferObjectFailed = 206
+        cudaErrorArrayIsMapped = 207
+        cudaErrorAlreadyMapped = 208
+        cudaErrorNoKernelImageForDevice = 209
+        cudaErrorAlreadyAcquired = 210
+        cudaErrorNotMapped = 211
+        cudaErrorNotMappedAsArray = 212
+        cudaErrorNotMappedAsPointer = 213
+        cudaErrorECCUncorrectable = 214
+        cudaErrorUnsupportedLimit = 215
+        cudaErrorDeviceAlreadyInUse = 216
+        cudaErrorPeerAccessUnsupported = 217
+        cudaErrorInvalidPtx = 218
+        cudaErrorInvalidGraphicsContext = 219
+        cudaErrorNvlinkUncorrectable = 220
+        cudaErrorJitCompilerNotFound = 221
+        cudaErrorUnsupportedPtxVersion = 222
+        cudaErrorJitCompilationDisabled = 223
+        cudaErrorUnsupportedExecAffinity = 224
+        cudaErrorUnsupportedDevSideSync = 225
+        cudaErrorContained = 226
+        cudaErrorInvalidSource = 300
+        cudaErrorFileNotFound = 301
+        cudaErrorSharedObjectSymbolNotFound = 302
+        cudaErrorSharedObjectInitFailed = 303
+        cudaErrorOperatingSystem = 304
+        cudaErrorInvalidResourceHandle = 400
+        cudaErrorIllegalState = 401
+        cudaErrorLossyQuery = 402
+        cudaErrorSymbolNotFound = 500
+        cudaErrorNotReady = 600
+        cudaErrorIllegalAddress = 700
+        cudaErrorLaunchOutOfResources = 701
+        cudaErrorLaunchTimeout = 702
+        cudaErrorLaunchIncompatibleTexturing = 703
+        cudaErrorPeerAccessAlreadyEnabled = 704
+        cudaErrorPeerAccessNotEnabled = 705
+        cudaErrorSetOnActiveProcess = 708
+        cudaErrorContextIsDestroyed = 709
+        cudaErrorAssert = 710
+        cudaErrorTooManyPeers = 711
+        cudaErrorHostMemoryAlreadyRegistered = 712
+        cudaErrorHostMemoryNotRegistered = 713
+        cudaErrorHardwareStackError = 714
+        cudaErrorIllegalInstruction = 715
+        cudaErrorMisalignedAddress = 716
+        cudaErrorInvalidAddressSpace = 717
+        cudaErrorInvalidPc = 718
+        cudaErrorLaunchFailure = 719
+        cudaErrorCooperativeLaunchTooLarge = 720
+        cudaErrorTensorMemoryLeak = 721
+        cudaErrorNotPermitted = 800
+        cudaErrorNotSupported = 801
+        cudaErrorSystemNotReady = 802
+        cudaErrorSystemDriverMismatch = 803
+        cudaErrorCompatNotSupportedOnDevice = 804
+        cudaErrorMpsConnectionFailed = 805
+        cudaErrorMpsRpcFailure = 806
+        cudaErrorMpsServerNotReady = 807
+        cudaErrorMpsMaxClientsReached = 808
+        cudaErrorMpsMaxConnectionsReached = 809
+        cudaErrorMpsClientTerminated = 810
+        cudaErrorCdpNotSupported = 811
+        cudaErrorCdpVersionMismatch = 812
+        cudaErrorStreamCaptureUnsupported = 900
+        cudaErrorStreamCaptureInvalidated = 901
+        cudaErrorStreamCaptureMerge = 902
+        cudaErrorStreamCaptureUnmatched = 903
+        cudaErrorStreamCaptureUnjoined = 904
+        cudaErrorStreamCaptureIsolation = 905
+        cudaErrorStreamCaptureImplicit = 906
+        cudaErrorCapturedEvent = 907
+        cudaErrorStreamCaptureWrongThread = 908
+        cudaErrorTimeout = 909
+        cudaErrorGraphExecUpdateFailure = 910
+        cudaErrorExternalDevice = 911
+        cudaErrorInvalidClusterSize = 912
+        cudaErrorFunctionNotLoaded = 913
+        cudaErrorInvalidResourceType = 914
+        cudaErrorInvalidResourceConfiguration = 915
+        cudaErrorUnknown = 999
+        cudaErrorApiFailureBase = 10000
+
+    ctypedef cudaError cudaError_t
+
+    cdef struct cudaChannelFormatDesc:
+        int x
+        int y
+        int z
+        int w
+        cudaChannelFormatKind f
+
+    cdef struct cudaArray:
+        pass
+    ctypedef cudaArray* cudaArray_t
+
+    cdef struct cudaArray:
+        pass
+    ctypedef cudaArray* cudaArray_const_t
+
+    cdef struct cudaMipmappedArray:
+        pass
+    ctypedef cudaMipmappedArray* cudaMipmappedArray_t
+
+    cdef struct cudaMipmappedArray:
+        pass
+    ctypedef cudaMipmappedArray* cudaMipmappedArray_const_t
+
+    cdef struct anon_struct0:
+        unsigned int width
+        unsigned int height
+        unsigned int depth
+
+    cdef struct cudaArraySparseProperties:
+        anon_struct0 tileExtent
+        unsigned int miptailFirstLevel
+        unsigned long long miptailSize
+        unsigned int flags
+        unsigned int reserved[4]
+
+    cdef struct cudaArrayMemoryRequirements:
+        size_t size
+        size_t alignment
+        unsigned int reserved[4]
+
+    cdef struct cudaPitchedPtr:
+        void* ptr
+        size_t pitch
+        size_t xsize
+        size_t ysize
+
+    cdef struct cudaExtent:
+        size_t width
+        size_t height
+        size_t depth
+
+    cdef struct cudaPos:
+        size_t x
+        size_t y
+        size_t z
+
+    cdef struct cudaMemcpy3DParms:
+        cudaArray_t srcArray
+        cudaPos srcPos
+        cudaPitchedPtr srcPtr
+        cudaArray_t dstArray
+        cudaPos dstPos
+        cudaPitchedPtr dstPtr
+        cudaExtent extent
+        cudaMemcpyKind kind
+
+    cdef struct cudaMemcpyNodeParams:
+        int flags
+        int reserved[3]
+        cudaMemcpy3DParms copyParams
+
+    cdef struct cudaMemcpy3DPeerParms:
+        cudaArray_t srcArray
+        cudaPos srcPos
+        cudaPitchedPtr srcPtr
+        int srcDevice
+        cudaArray_t dstArray
+        cudaPos dstPos
+        cudaPitchedPtr dstPtr
+        int dstDevice
+        cudaExtent extent
+
+    cdef struct cudaMemsetParams:
+        void* dst
+        size_t pitch
+        unsigned int value
+        unsigned int elementSize
+        size_t width
+        size_t height
+
+    cdef struct cudaMemsetParamsV2:
+        void* dst
+        size_t pitch
+        unsigned int value
+        unsigned int elementSize
+        size_t width
+        size_t height
+
+    cdef struct cudaAccessPolicyWindow:
+        void* base_ptr
+        size_t num_bytes
+        float hitRatio
+        cudaAccessProperty hitProp
+        cudaAccessProperty missProp
+
+    ctypedef void (*cudaHostFn_t)(void* userData)
+
+    cdef struct cudaHostNodeParams:
+        cudaHostFn_t fn
+        void* userData
+
+    cdef struct cudaHostNodeParamsV2:
+        cudaHostFn_t fn
+        void* userData
+
+    cdef struct anon_struct1:
+        cudaArray_t array
+
+    cdef struct anon_struct2:
+        cudaMipmappedArray_t mipmap
+
+    cdef struct anon_struct3:
+        void* devPtr
+        cudaChannelFormatDesc desc
+        size_t sizeInBytes
+
+    cdef struct anon_struct4:
+        void* devPtr
+        cudaChannelFormatDesc desc
+        size_t width
+        size_t height
+        size_t pitchInBytes
+
+    cdef union anon_union0:
+        anon_struct1 array
+        anon_struct2 mipmap
+        anon_struct3 linear
+        anon_struct4 pitch2D
+
+    cdef struct cudaResourceDesc:
+        cudaResourceType resType
+        anon_union0 res
+
+    cdef struct cudaResourceViewDesc:
+        cudaResourceViewFormat format
+        size_t width
+        size_t height
+        size_t depth
+        unsigned int firstMipmapLevel
+        unsigned int lastMipmapLevel
+        unsigned int firstLayer
+        unsigned int lastLayer
+
+    cdef struct cudaPointerAttributes:
+        cudaMemoryType type
+        int device
+        void* devicePointer
+        void* hostPointer
+
+    cdef struct cudaFuncAttributes:
+        size_t sharedSizeBytes
+        size_t constSizeBytes
+        size_t localSizeBytes
+        int maxThreadsPerBlock
+        int numRegs
+        int ptxVersion
+        int binaryVersion
+        int cacheModeCA
+        int maxDynamicSharedSizeBytes
+        int preferredShmemCarveout
+        int clusterDimMustBeSet
+        int requiredClusterWidth
+        int requiredClusterHeight
+        int requiredClusterDepth
+        int clusterSchedulingPolicyPreference
+        int nonPortableClusterSizeAllowed
+        int reserved[16]
+
+    cdef struct cudaMemLocation:
+        cudaMemLocationType type
+        int id
+
+    cdef struct cudaMemAccessDesc:
+        cudaMemLocation location
+        cudaMemAccessFlags flags
+
+    cdef struct cudaMemPoolProps:
+        cudaMemAllocationType allocType
+        cudaMemAllocationHandleType handleTypes
+        cudaMemLocation location
+        void* win32SecurityAttributes
+        size_t maxSize
+        unsigned short usage
+        unsigned char reserved[54]
+
+    cdef struct cudaMemPoolPtrExportData:
+        unsigned char reserved[64]
+
+    cdef struct cudaMemAllocNodeParams:
+        cudaMemPoolProps poolProps
+        const cudaMemAccessDesc* accessDescs
+        size_t accessDescCount
+        size_t bytesize
+        void* dptr
+
+    cdef struct cudaMemAllocNodeParamsV2:
+        cudaMemPoolProps poolProps
+        const cudaMemAccessDesc* accessDescs
+        size_t accessDescCount
+        size_t bytesize
+        void* dptr
+
+    cdef struct cudaMemFreeNodeParams:
+        void* dptr
+
+    cdef struct cudaMemcpyAttributes:
+        cudaMemcpySrcAccessOrder srcAccessOrder
+        cudaMemLocation srcLocHint
+        cudaMemLocation dstLocHint
+        unsigned int flags
+
+    cdef struct cudaOffset3D:
+        size_t x
+        size_t y
+        size_t z
+
+    cdef struct anon_struct5:
+        void* ptr
+        size_t rowLength
+        size_t layerHeight
+        cudaMemLocation locHint
+
+    cdef struct anon_struct6:
+        cudaArray_t array
+        cudaOffset3D offset
+
+    cdef union anon_union1:
+        anon_struct5 ptr
+        anon_struct6 array
+
+    cdef struct cudaMemcpy3DOperand:
+        cudaMemcpy3DOperandType type
+        anon_union1 op
+
+    cdef struct cudaMemcpy3DBatchOp:
+        cudaMemcpy3DOperand src
+        cudaMemcpy3DOperand dst
+        cudaExtent extent
+        cudaMemcpySrcAccessOrder srcAccessOrder
+        unsigned int flags
+
+    cdef struct CUuuid_st:
+        char bytes[16]
+
+    ctypedef CUuuid_st CUuuid
+
+    ctypedef CUuuid_st cudaUUID_t
+
+    cdef struct cudaDeviceProp:
+        char name[256]
+        cudaUUID_t uuid
+        char luid[8]
+        unsigned int luidDeviceNodeMask
+        size_t totalGlobalMem
+        size_t sharedMemPerBlock
+        int regsPerBlock
+        int warpSize
+        size_t memPitch
+        int maxThreadsPerBlock
+        int maxThreadsDim[3]
+        int maxGridSize[3]
+        int clockRate
+        size_t totalConstMem
+        int major
+        int minor
+        size_t textureAlignment
+        size_t texturePitchAlignment
+        int deviceOverlap
+        int multiProcessorCount
+        int kernelExecTimeoutEnabled
+        int integrated
+        int canMapHostMemory
+        int computeMode
+        int maxTexture1D
+        int maxTexture1DMipmap
+        int maxTexture1DLinear
+        int maxTexture2D[2]
+        int maxTexture2DMipmap[2]
+        int maxTexture2DLinear[3]
+        int maxTexture2DGather[2]
+        int maxTexture3D[3]
+        int maxTexture3DAlt[3]
+        int maxTextureCubemap
+        int maxTexture1DLayered[2]
+        int maxTexture2DLayered[3]
+        int maxTextureCubemapLayered[2]
+        int maxSurface1D
+        int maxSurface2D[2]
+        int maxSurface3D[3]
+        int maxSurface1DLayered[2]
+        int maxSurface2DLayered[3]
+        int maxSurfaceCubemap
+        int maxSurfaceCubemapLayered[2]
+        size_t surfaceAlignment
+        int concurrentKernels
+        int ECCEnabled
+        int pciBusID
+        int pciDeviceID
+        int pciDomainID
+        int tccDriver
+        int asyncEngineCount
+        int unifiedAddressing
+        int memoryClockRate
+        int memoryBusWidth
+        int l2CacheSize
+        int persistingL2CacheMaxSize
+        int maxThreadsPerMultiProcessor
+        int streamPrioritiesSupported
+        int globalL1CacheSupported
+        int localL1CacheSupported
+        size_t sharedMemPerMultiprocessor
+        int regsPerMultiprocessor
+        int managedMemory
+        int isMultiGpuBoard
+        int multiGpuBoardGroupID
+        int hostNativeAtomicSupported
+        int singleToDoublePrecisionPerfRatio
+        int pageableMemoryAccess
+        int concurrentManagedAccess
+        int computePreemptionSupported
+        int canUseHostPointerForRegisteredMem
+        int cooperativeLaunch
+        int cooperativeMultiDeviceLaunch
+        size_t sharedMemPerBlockOptin
+        int pageableMemoryAccessUsesHostPageTables
+        int directManagedMemAccessFromHost
+        int maxBlocksPerMultiProcessor
+        int accessPolicyMaxWindowSize
+        size_t reservedSharedMemPerBlock
+        int hostRegisterSupported
+        int sparseCudaArraySupported
+        int hostRegisterReadOnlySupported
+        int timelineSemaphoreInteropSupported
+        int memoryPoolsSupported
+        int gpuDirectRDMASupported
+        unsigned int gpuDirectRDMAFlushWritesOptions
+        int gpuDirectRDMAWritesOrdering
+        unsigned int memoryPoolSupportedHandleTypes
+        int deferredMappingCudaArraySupported
+        int ipcEventSupported
+        int clusterLaunch
+        int unifiedFunctionPointers
+        int reserved[63]
+
+    cdef struct cudaIpcEventHandle_st:
+        char reserved[64]
+
+    ctypedef cudaIpcEventHandle_st cudaIpcEventHandle_t
+
+    cdef struct cudaIpcMemHandle_st:
+        char reserved[64]
+
+    ctypedef cudaIpcMemHandle_st cudaIpcMemHandle_t
+
+    cdef struct cudaMemFabricHandle_st:
+        char reserved[64]
+
+    ctypedef cudaMemFabricHandle_st cudaMemFabricHandle_t
+
+    cdef struct anon_struct7:
+        void* handle
+        const void* name
+
+    cdef union anon_union2:
+        int fd
+        anon_struct7 win32
+        const void* nvSciBufObject
+
+    cdef struct cudaExternalMemoryHandleDesc:
+        cudaExternalMemoryHandleType type
+        anon_union2 handle
+        unsigned long long size
+        unsigned int flags
+
+    cdef struct cudaExternalMemoryBufferDesc:
+        unsigned long long offset
+        unsigned long long size
+        unsigned int flags
+
+    cdef struct cudaExternalMemoryMipmappedArrayDesc:
+        unsigned long long offset
+        cudaChannelFormatDesc formatDesc
+        cudaExtent extent
+        unsigned int flags
+        unsigned int numLevels
+
+    cdef struct anon_struct8:
+        void* handle
+        const void* name
+
+    cdef union anon_union3:
+        int fd
+        anon_struct8 win32
+        const void* nvSciSyncObj
+
+    cdef struct cudaExternalSemaphoreHandleDesc:
+        cudaExternalSemaphoreHandleType type
+        anon_union3 handle
+        unsigned int flags
+
+    cdef struct anon_struct15:
+        unsigned long long value
+
+    cdef union anon_union6:
+        void* fence
+        unsigned long long reserved
+
+    cdef struct anon_struct16:
+        unsigned long long key
+
+    cdef struct anon_struct17:
+        anon_struct15 fence
+        anon_union6 nvSciSync
+        anon_struct16 keyedMutex
+        unsigned int reserved[12]
+
+    cdef struct cudaExternalSemaphoreSignalParams:
+        anon_struct17 params
+        unsigned int flags
+        unsigned int reserved[16]
+
+    cdef struct anon_struct18:
+        unsigned long long value
+
+    cdef union anon_union7:
+        void* fence
+        unsigned long long reserved
+
+    cdef struct anon_struct19:
+        unsigned long long key
+        unsigned int timeoutMs
+
+    cdef struct anon_struct20:
+        anon_struct18 fence
+        anon_union7 nvSciSync
+        anon_struct19 keyedMutex
+        unsigned int reserved[10]
+
+    cdef struct cudaExternalSemaphoreWaitParams:
+        anon_struct20 params
+        unsigned int flags
+        unsigned int reserved[16]
+
+    cdef struct CUstream_st:
+        pass
+    ctypedef CUstream_st* cudaStream_t
+
+    cdef struct CUevent_st:
+        pass
+    ctypedef CUevent_st* cudaEvent_t
+
+    cdef struct cudaGraphicsResource:
+        pass
+    ctypedef cudaGraphicsResource* cudaGraphicsResource_t
+
+    cdef struct CUexternalMemory_st:
+        pass
+    ctypedef CUexternalMemory_st* cudaExternalMemory_t
+
+    cdef struct CUexternalSemaphore_st:
+        pass
+    ctypedef CUexternalSemaphore_st* cudaExternalSemaphore_t
+
+    cdef struct CUgraph_st:
+        pass
+    ctypedef CUgraph_st* cudaGraph_t
+
+    cdef struct CUgraphNode_st:
+        pass
+    ctypedef CUgraphNode_st* cudaGraphNode_t
+
+    cdef struct CUuserObject_st:
+        pass
+    ctypedef CUuserObject_st* cudaUserObject_t
+
+    ctypedef unsigned long long cudaGraphConditionalHandle
+
+    cdef struct CUfunc_st:
+        pass
+    ctypedef CUfunc_st* cudaFunction_t
+
+    cdef struct CUkern_st:
+        pass
+    ctypedef CUkern_st* cudaKernel_t
+
+    cdef struct cudalibraryHostUniversalFunctionAndDataTable:
+        void* functionTable
+        size_t functionWindowSize
+        void* dataTable
+        size_t dataWindowSize
+
+    cdef struct CUlib_st:
+        pass
+    ctypedef CUlib_st* cudaLibrary_t
+
+    cdef struct CUmemPoolHandle_st:
+        pass
+    ctypedef CUmemPoolHandle_st* cudaMemPool_t
+
+    cdef struct cudaKernelNodeParams:
+        void* func
+        dim3 gridDim
+        dim3 blockDim
+        unsigned int sharedMemBytes
+        void** kernelParams
+        void** extra
+
+    cdef struct cudaKernelNodeParamsV2:
+        void* func
+        dim3 gridDim
+        dim3 blockDim
+        unsigned int sharedMemBytes
+        void** kernelParams
+        void** extra
+
+    cdef struct cudaExternalSemaphoreSignalNodeParams:
+        cudaExternalSemaphore_t* extSemArray
+        const cudaExternalSemaphoreSignalParams* paramsArray
+        unsigned int numExtSems
+
+    cdef struct cudaExternalSemaphoreSignalNodeParamsV2:
+        cudaExternalSemaphore_t* extSemArray
+        const cudaExternalSemaphoreSignalParams* paramsArray
+        unsigned int numExtSems
+
+    cdef struct cudaExternalSemaphoreWaitNodeParams:
+        cudaExternalSemaphore_t* extSemArray
+        const cudaExternalSemaphoreWaitParams* paramsArray
+        unsigned int numExtSems
+
+    cdef struct cudaExternalSemaphoreWaitNodeParamsV2:
+        cudaExternalSemaphore_t* extSemArray
+        const cudaExternalSemaphoreWaitParams* paramsArray
+        unsigned int numExtSems
+
+    cdef struct cudaConditionalNodeParams:
+        cudaGraphConditionalHandle handle
+        cudaGraphConditionalNodeType type
+        unsigned int size
+        cudaGraph_t* phGraph_out
+
+    cdef struct cudaChildGraphNodeParams:
+        cudaGraph_t graph
+        cudaGraphChildGraphNodeOwnership ownership
+
+    cdef struct cudaEventRecordNodeParams:
+        cudaEvent_t event
+
+    cdef struct cudaEventWaitNodeParams:
+        cudaEvent_t event
+
+    cdef struct cudaGraphNodeParams:
+        cudaGraphNodeType type
+        int reserved0[3]
+        long long reserved1[29]
+        cudaKernelNodeParamsV2 kernel
+        cudaMemcpyNodeParams memcpy
+        cudaMemsetParamsV2 memset
+        cudaHostNodeParamsV2 host
+        cudaChildGraphNodeParams graph
+        cudaEventWaitNodeParams eventWait
+        cudaEventRecordNodeParams eventRecord
+        cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal
+        cudaExternalSemaphoreWaitNodeParamsV2 extSemWait
+        cudaMemAllocNodeParamsV2 alloc
+        cudaMemFreeNodeParams free
+        cudaConditionalNodeParams conditional
+        long long reserved2
+
+    cdef enum cudaGraphDependencyType_enum:
+        cudaGraphDependencyTypeDefault = 0
+        cudaGraphDependencyTypeProgrammatic = 1
+
+    ctypedef cudaGraphDependencyType_enum cudaGraphDependencyType
+
+    cdef struct cudaGraphEdgeData_st:
+        unsigned char from_port
+        unsigned char to_port
+        unsigned char type
+        unsigned char reserved[5]
+
+    ctypedef cudaGraphEdgeData_st cudaGraphEdgeData
+
+    cdef struct CUgraphExec_st:
+        pass
+    ctypedef CUgraphExec_st* cudaGraphExec_t
+
+    cdef enum cudaGraphInstantiateResult:
+        cudaGraphInstantiateSuccess = 0
+        cudaGraphInstantiateError = 1
+        cudaGraphInstantiateInvalidStructure = 2
+        cudaGraphInstantiateNodeOperationNotSupported = 3
+        cudaGraphInstantiateMultipleDevicesNotSupported = 4
+        cudaGraphInstantiateConditionalHandleUnused = 5
+
+    cdef struct cudaGraphInstantiateParams_st:
+        unsigned long long flags
+        cudaStream_t uploadStream
+        cudaGraphNode_t errNode_out
+        cudaGraphInstantiateResult result_out
+
+    ctypedef cudaGraphInstantiateParams_st cudaGraphInstantiateParams
+
+    cdef struct cudaGraphExecUpdateResultInfo_st:
+        cudaGraphExecUpdateResult result
+        cudaGraphNode_t errorNode
+        cudaGraphNode_t errorFromNode
+
+    ctypedef cudaGraphExecUpdateResultInfo_st cudaGraphExecUpdateResultInfo
+
+    cdef struct CUgraphDeviceUpdatableNode_st:
+        pass
+    ctypedef CUgraphDeviceUpdatableNode_st* cudaGraphDeviceNode_t
+
+    cdef struct anon_struct21:
+        const void* pValue
+        size_t offset
+        size_t size
+
+    cdef union anon_union9:
+        dim3 gridDim
+        anon_struct21 param
+        unsigned int isEnabled
+
+    cdef struct cudaGraphKernelNodeUpdate:
+        cudaGraphDeviceNode_t node
+        cudaGraphKernelNodeField field
+        anon_union9 updateData
+
+    cdef enum cudaLaunchMemSyncDomain:
+        cudaLaunchMemSyncDomainDefault = 0
+        cudaLaunchMemSyncDomainRemote = 1
+
+    cdef struct cudaLaunchMemSyncDomainMap_st:
+        unsigned char default_
+        unsigned char remote
+
+    ctypedef cudaLaunchMemSyncDomainMap_st cudaLaunchMemSyncDomainMap
+
+    cdef enum cudaLaunchAttributeID:
+        cudaLaunchAttributeIgnore = 0
+        cudaLaunchAttributeAccessPolicyWindow = 1
+        cudaLaunchAttributeCooperative = 2
+        cudaLaunchAttributeSynchronizationPolicy = 3
+        cudaLaunchAttributeClusterDimension = 4
+        cudaLaunchAttributeClusterSchedulingPolicyPreference = 5
+        cudaLaunchAttributeProgrammaticStreamSerialization = 6
+        cudaLaunchAttributeProgrammaticEvent = 7
+        cudaLaunchAttributePriority = 8
+        cudaLaunchAttributeMemSyncDomainMap = 9
+        cudaLaunchAttributeMemSyncDomain = 10
+        cudaLaunchAttributePreferredClusterDimension = 11
+        cudaLaunchAttributeLaunchCompletionEvent = 12
+        cudaLaunchAttributeDeviceUpdatableKernelNode = 13
+        cudaLaunchAttributePreferredSharedMemoryCarveout = 14
+
+    cdef struct anon_struct22:
+        unsigned int x
+        unsigned int y
+        unsigned int z
+
+    cdef struct anon_struct23:
+        cudaEvent_t event
+        int flags
+        int triggerAtBlockStart
+
+    cdef struct anon_struct24:
+        unsigned int x
+        unsigned int y
+        unsigned int z
+
+    cdef struct anon_struct25:
+        cudaEvent_t event
+        int flags
+
+    cdef struct anon_struct26:
+        int deviceUpdatable
+        cudaGraphDeviceNode_t devNode
+
+    cdef union cudaLaunchAttributeValue:
+        char pad[64]
+        cudaAccessPolicyWindow accessPolicyWindow
+        int cooperative
+        cudaSynchronizationPolicy syncPolicy
+        anon_struct22 clusterDim
+        cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference
+        int programmaticStreamSerializationAllowed
+        anon_struct23 programmaticEvent
+        int priority
+        cudaLaunchMemSyncDomainMap memSyncDomainMap
+        cudaLaunchMemSyncDomain memSyncDomain
+        anon_struct24 preferredClusterDim
+        anon_struct25 launchCompletionEvent
+        anon_struct26 deviceUpdatableKernelNode
+        unsigned int sharedMemCarveout
+
+    cdef struct cudaLaunchAttribute_st:
+        cudaLaunchAttributeID id
+        cudaLaunchAttributeValue val
+
+    ctypedef cudaLaunchAttribute_st cudaLaunchAttribute
+
+    cdef struct cudaAsyncCallbackEntry:
+        pass
+    ctypedef cudaAsyncCallbackEntry* cudaAsyncCallbackHandle_t
+
+    cdef enum cudaAsyncNotificationType_enum:
+        cudaAsyncNotificationTypeOverBudget = 1
+
+    ctypedef cudaAsyncNotificationType_enum cudaAsyncNotificationType
+
+    cdef struct anon_struct27:
+        unsigned long long bytesOverBudget
+
+    cdef union anon_union10:
+        anon_struct27 overBudget
+
+    cdef struct cudaAsyncNotificationInfo:
+        cudaAsyncNotificationType type
+        anon_union10 info
+
+    ctypedef cudaAsyncNotificationInfo cudaAsyncNotificationInfo_t
+
+    ctypedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t* , void* , cudaAsyncCallbackHandle_t )
+
+    cdef enum cudaChannelFormatKind:
+        cudaChannelFormatKindSigned = 0
+        cudaChannelFormatKindUnsigned = 1
+        cudaChannelFormatKindFloat = 2
+        cudaChannelFormatKindNone = 3
+        cudaChannelFormatKindNV12 = 4
+        cudaChannelFormatKindUnsignedNormalized8X1 = 5
+        cudaChannelFormatKindUnsignedNormalized8X2 = 6
+        cudaChannelFormatKindUnsignedNormalized8X4 = 7
+        cudaChannelFormatKindUnsignedNormalized16X1 = 8
+        cudaChannelFormatKindUnsignedNormalized16X2 = 9
+        cudaChannelFormatKindUnsignedNormalized16X4 = 10
+        cudaChannelFormatKindSignedNormalized8X1 = 11
+        cudaChannelFormatKindSignedNormalized8X2 = 12
+        cudaChannelFormatKindSignedNormalized8X4 = 13
+        cudaChannelFormatKindSignedNormalized16X1 = 14
+        cudaChannelFormatKindSignedNormalized16X2 = 15
+        cudaChannelFormatKindSignedNormalized16X4 = 16
+        cudaChannelFormatKindUnsignedBlockCompressed1 = 17
+        cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18
+        cudaChannelFormatKindUnsignedBlockCompressed2 = 19
+        cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20
+        cudaChannelFormatKindUnsignedBlockCompressed3 = 21
+        cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22
+        cudaChannelFormatKindUnsignedBlockCompressed4 = 23
+        cudaChannelFormatKindSignedBlockCompressed4 = 24
+        cudaChannelFormatKindUnsignedBlockCompressed5 = 25
+        cudaChannelFormatKindSignedBlockCompressed5 = 26
+        cudaChannelFormatKindUnsignedBlockCompressed6H = 27
+        cudaChannelFormatKindSignedBlockCompressed6H = 28
+        cudaChannelFormatKindUnsignedBlockCompressed7 = 29
+        cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30
+        cudaChannelFormatKindUnsignedNormalized1010102 = 31
+
+    cdef enum cudaMemoryType:
+        cudaMemoryTypeUnregistered = 0
+        cudaMemoryTypeHost = 1
+        cudaMemoryTypeDevice = 2
+        cudaMemoryTypeManaged = 3
+
+    cdef enum cudaMemcpyKind:
+        cudaMemcpyHostToHost = 0
+        cudaMemcpyHostToDevice = 1
+        cudaMemcpyDeviceToHost = 2
+        cudaMemcpyDeviceToDevice = 3
+        cudaMemcpyDefault = 4
+
+    cdef enum cudaAccessProperty:
+        cudaAccessPropertyNormal = 0
+        cudaAccessPropertyStreaming = 1
+        cudaAccessPropertyPersisting = 2
+
+    cdef enum cudaStreamCaptureStatus:
+        cudaStreamCaptureStatusNone = 0
+        cudaStreamCaptureStatusActive = 1
+        cudaStreamCaptureStatusInvalidated = 2
+
+    cdef enum cudaStreamCaptureMode:
+        cudaStreamCaptureModeGlobal = 0
+        cudaStreamCaptureModeThreadLocal = 1
+        cudaStreamCaptureModeRelaxed = 2
+
+    cdef enum cudaSynchronizationPolicy:
+        cudaSyncPolicyAuto = 1
+        cudaSyncPolicySpin = 2
+        cudaSyncPolicyYield = 3
+        cudaSyncPolicyBlockingSync = 4
+
+    cdef enum cudaClusterSchedulingPolicy:
+        cudaClusterSchedulingPolicyDefault = 0
+        cudaClusterSchedulingPolicySpread = 1
+        cudaClusterSchedulingPolicyLoadBalancing = 2
+
+    cdef enum cudaStreamUpdateCaptureDependenciesFlags:
+        cudaStreamAddCaptureDependencies = 0
+        cudaStreamSetCaptureDependencies = 1
+
+    cdef enum cudaUserObjectFlags:
+        cudaUserObjectNoDestructorSync = 1
+
+    cdef enum cudaUserObjectRetainFlags:
+        cudaGraphUserObjectMove = 1
+
+    cdef enum cudaGraphicsRegisterFlags:
+        cudaGraphicsRegisterFlagsNone = 0
+        cudaGraphicsRegisterFlagsReadOnly = 1
+        cudaGraphicsRegisterFlagsWriteDiscard = 2
+        cudaGraphicsRegisterFlagsSurfaceLoadStore = 4
+        cudaGraphicsRegisterFlagsTextureGather = 8
+
+    cdef enum cudaGraphicsMapFlags:
+        cudaGraphicsMapFlagsNone = 0
+        cudaGraphicsMapFlagsReadOnly = 1
+        cudaGraphicsMapFlagsWriteDiscard = 2
+
+    cdef enum cudaGraphicsCubeFace:
+        cudaGraphicsCubeFacePositiveX = 0
+        cudaGraphicsCubeFaceNegativeX = 1
+        cudaGraphicsCubeFacePositiveY = 2
+        cudaGraphicsCubeFaceNegativeY = 3
+        cudaGraphicsCubeFacePositiveZ = 4
+        cudaGraphicsCubeFaceNegativeZ = 5
+
+    cdef enum cudaResourceType:
+        cudaResourceTypeArray = 0
+        cudaResourceTypeMipmappedArray = 1
+        cudaResourceTypeLinear = 2
+        cudaResourceTypePitch2D = 3
+
+    cdef enum cudaResourceViewFormat:
+        cudaResViewFormatNone = 0
+        cudaResViewFormatUnsignedChar1 = 1
+        cudaResViewFormatUnsignedChar2 = 2
+        cudaResViewFormatUnsignedChar4 = 3
+        cudaResViewFormatSignedChar1 = 4
+        cudaResViewFormatSignedChar2 = 5
+        cudaResViewFormatSignedChar4 = 6
+        cudaResViewFormatUnsignedShort1 = 7
+        cudaResViewFormatUnsignedShort2 = 8
+        cudaResViewFormatUnsignedShort4 = 9
+        cudaResViewFormatSignedShort1 = 10
+        cudaResViewFormatSignedShort2 = 11
+        cudaResViewFormatSignedShort4 = 12
+        cudaResViewFormatUnsignedInt1 = 13
+        cudaResViewFormatUnsignedInt2 = 14
+        cudaResViewFormatUnsignedInt4 = 15
+        cudaResViewFormatSignedInt1 = 16
+        cudaResViewFormatSignedInt2 = 17
+        cudaResViewFormatSignedInt4 = 18
+        cudaResViewFormatHalf1 = 19
+        cudaResViewFormatHalf2 = 20
+        cudaResViewFormatHalf4 = 21
+        cudaResViewFormatFloat1 = 22
+        cudaResViewFormatFloat2 = 23
+        cudaResViewFormatFloat4 = 24
+        cudaResViewFormatUnsignedBlockCompressed1 = 25
+        cudaResViewFormatUnsignedBlockCompressed2 = 26
+        cudaResViewFormatUnsignedBlockCompressed3 = 27
+        cudaResViewFormatUnsignedBlockCompressed4 = 28
+        cudaResViewFormatSignedBlockCompressed4 = 29
+        cudaResViewFormatUnsignedBlockCompressed5 = 30
+        cudaResViewFormatSignedBlockCompressed5 = 31
+        cudaResViewFormatUnsignedBlockCompressed6H = 32
+        cudaResViewFormatSignedBlockCompressed6H = 33
+        cudaResViewFormatUnsignedBlockCompressed7 = 34
+
+    cdef enum cudaFuncAttribute:
+        cudaFuncAttributeMaxDynamicSharedMemorySize = 8
+        cudaFuncAttributePreferredSharedMemoryCarveout = 9
+        cudaFuncAttributeClusterDimMustBeSet = 10
+        cudaFuncAttributeRequiredClusterWidth = 11
+        cudaFuncAttributeRequiredClusterHeight = 12
+        cudaFuncAttributeRequiredClusterDepth = 13
+        cudaFuncAttributeNonPortableClusterSizeAllowed = 14
+        cudaFuncAttributeClusterSchedulingPolicyPreference = 15
+        cudaFuncAttributeMax = 16
+
+    cdef enum cudaFuncCache:
+        cudaFuncCachePreferNone = 0
+        cudaFuncCachePreferShared = 1
+        cudaFuncCachePreferL1 = 2
+        cudaFuncCachePreferEqual = 3
+
+    cdef enum cudaSharedMemConfig:
+        cudaSharedMemBankSizeDefault = 0
+        cudaSharedMemBankSizeFourByte = 1
+        cudaSharedMemBankSizeEightByte = 2
+
+    cdef enum cudaSharedCarveout:
+        cudaSharedmemCarveoutDefault = -1
+        cudaSharedmemCarveoutMaxL1 = 0
+        cudaSharedmemCarveoutMaxShared = 100
+
+    cdef enum cudaComputeMode:
+        cudaComputeModeDefault = 0
+        cudaComputeModeExclusive = 1
+        cudaComputeModeProhibited = 2
+        cudaComputeModeExclusiveProcess = 3
+
+    cdef enum cudaLimit:
+        cudaLimitStackSize = 0
+        cudaLimitPrintfFifoSize = 1
+        cudaLimitMallocHeapSize = 2
+        cudaLimitDevRuntimeSyncDepth = 3
+        cudaLimitDevRuntimePendingLaunchCount = 4
+        cudaLimitMaxL2FetchGranularity = 5
+        cudaLimitPersistingL2CacheSize = 6
+
+    cdef enum cudaMemoryAdvise:
+        cudaMemAdviseSetReadMostly = 1
+        cudaMemAdviseUnsetReadMostly = 2
+        cudaMemAdviseSetPreferredLocation = 3
+        cudaMemAdviseUnsetPreferredLocation = 4
+        cudaMemAdviseSetAccessedBy = 5
+        cudaMemAdviseUnsetAccessedBy = 6
+
+    cdef enum cudaMemRangeAttribute:
+        cudaMemRangeAttributeReadMostly = 1
+        cudaMemRangeAttributePreferredLocation = 2
+        cudaMemRangeAttributeAccessedBy = 3
+        cudaMemRangeAttributeLastPrefetchLocation = 4
+        cudaMemRangeAttributePreferredLocationType = 5
+        cudaMemRangeAttributePreferredLocationId = 6
+        cudaMemRangeAttributeLastPrefetchLocationType = 7
+        cudaMemRangeAttributeLastPrefetchLocationId = 8
+
+    cdef enum cudaFlushGPUDirectRDMAWritesOptions:
+        cudaFlushGPUDirectRDMAWritesOptionHost = 1
+        cudaFlushGPUDirectRDMAWritesOptionMemOps = 2
+
+    cdef enum cudaGPUDirectRDMAWritesOrdering:
+        cudaGPUDirectRDMAWritesOrderingNone = 0
+        cudaGPUDirectRDMAWritesOrderingOwner = 100
+        cudaGPUDirectRDMAWritesOrderingAllDevices = 200
+
+    cdef enum cudaFlushGPUDirectRDMAWritesScope:
+        cudaFlushGPUDirectRDMAWritesToOwner = 100
+        cudaFlushGPUDirectRDMAWritesToAllDevices = 200
+
+    cdef enum cudaFlushGPUDirectRDMAWritesTarget:
+        cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = 0
+
+    cdef enum cudaDeviceAttr:
+        cudaDevAttrMaxThreadsPerBlock = 1
+        cudaDevAttrMaxBlockDimX = 2
+        cudaDevAttrMaxBlockDimY = 3
+        cudaDevAttrMaxBlockDimZ = 4
+        cudaDevAttrMaxGridDimX = 5
+        cudaDevAttrMaxGridDimY = 6
+        cudaDevAttrMaxGridDimZ = 7
+        cudaDevAttrMaxSharedMemoryPerBlock = 8
+        cudaDevAttrTotalConstantMemory = 9
+        cudaDevAttrWarpSize = 10
+        cudaDevAttrMaxPitch = 11
+        cudaDevAttrMaxRegistersPerBlock = 12
+        cudaDevAttrClockRate = 13
+        cudaDevAttrTextureAlignment = 14
+        cudaDevAttrGpuOverlap = 15
+        cudaDevAttrMultiProcessorCount = 16
+        cudaDevAttrKernelExecTimeout = 17
+        cudaDevAttrIntegrated = 18
+        cudaDevAttrCanMapHostMemory = 19
+        cudaDevAttrComputeMode = 20
+        cudaDevAttrMaxTexture1DWidth = 21
+        cudaDevAttrMaxTexture2DWidth = 22
+        cudaDevAttrMaxTexture2DHeight = 23
+        cudaDevAttrMaxTexture3DWidth = 24
+        cudaDevAttrMaxTexture3DHeight = 25
+        cudaDevAttrMaxTexture3DDepth = 26
+        cudaDevAttrMaxTexture2DLayeredWidth = 27
+        cudaDevAttrMaxTexture2DLayeredHeight = 28
+        cudaDevAttrMaxTexture2DLayeredLayers = 29
+        cudaDevAttrSurfaceAlignment = 30
+        cudaDevAttrConcurrentKernels = 31
+        cudaDevAttrEccEnabled = 32
+        cudaDevAttrPciBusId = 33
+        cudaDevAttrPciDeviceId = 34
+        cudaDevAttrTccDriver = 35
+        cudaDevAttrMemoryClockRate = 36
+        cudaDevAttrGlobalMemoryBusWidth = 37
+        cudaDevAttrL2CacheSize = 38
+        cudaDevAttrMaxThreadsPerMultiProcessor = 39
+        cudaDevAttrAsyncEngineCount = 40
+        cudaDevAttrUnifiedAddressing = 41
+        cudaDevAttrMaxTexture1DLayeredWidth = 42
+        cudaDevAttrMaxTexture1DLayeredLayers = 43
+        cudaDevAttrMaxTexture2DGatherWidth = 45
+        cudaDevAttrMaxTexture2DGatherHeight = 46
+        cudaDevAttrMaxTexture3DWidthAlt = 47
+        cudaDevAttrMaxTexture3DHeightAlt = 48
+        cudaDevAttrMaxTexture3DDepthAlt = 49
+        cudaDevAttrPciDomainId = 50
+        cudaDevAttrTexturePitchAlignment = 51
+        cudaDevAttrMaxTextureCubemapWidth = 52
+        cudaDevAttrMaxTextureCubemapLayeredWidth = 53
+        cudaDevAttrMaxTextureCubemapLayeredLayers = 54
+        cudaDevAttrMaxSurface1DWidth = 55
+        cudaDevAttrMaxSurface2DWidth = 56
+        cudaDevAttrMaxSurface2DHeight = 57
+        cudaDevAttrMaxSurface3DWidth = 58
+        cudaDevAttrMaxSurface3DHeight = 59
+        cudaDevAttrMaxSurface3DDepth = 60
+        cudaDevAttrMaxSurface1DLayeredWidth = 61
+        cudaDevAttrMaxSurface1DLayeredLayers = 62
+        cudaDevAttrMaxSurface2DLayeredWidth = 63
+        cudaDevAttrMaxSurface2DLayeredHeight = 64
+        cudaDevAttrMaxSurface2DLayeredLayers = 65
+        cudaDevAttrMaxSurfaceCubemapWidth = 66
+        cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67
+        cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68
+        cudaDevAttrMaxTexture1DLinearWidth = 69
+        cudaDevAttrMaxTexture2DLinearWidth = 70
+        cudaDevAttrMaxTexture2DLinearHeight = 71
+        cudaDevAttrMaxTexture2DLinearPitch = 72
+        cudaDevAttrMaxTexture2DMipmappedWidth = 73
+        cudaDevAttrMaxTexture2DMipmappedHeight = 74
+        cudaDevAttrComputeCapabilityMajor = 75
+        cudaDevAttrComputeCapabilityMinor = 76
+        cudaDevAttrMaxTexture1DMipmappedWidth = 77
+        cudaDevAttrStreamPrioritiesSupported = 78
+        cudaDevAttrGlobalL1CacheSupported = 79
+        cudaDevAttrLocalL1CacheSupported = 80
+        cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81
+        cudaDevAttrMaxRegistersPerMultiprocessor = 82
+        cudaDevAttrManagedMemory = 83
+        cudaDevAttrIsMultiGpuBoard = 84
+        cudaDevAttrMultiGpuBoardGroupID = 85
+        cudaDevAttrHostNativeAtomicSupported = 86
+        cudaDevAttrSingleToDoublePrecisionPerfRatio = 87
+        cudaDevAttrPageableMemoryAccess = 88
+        cudaDevAttrConcurrentManagedAccess = 89
+        cudaDevAttrComputePreemptionSupported = 90
+        cudaDevAttrCanUseHostPointerForRegisteredMem = 91
+        cudaDevAttrReserved92 = 92
+        cudaDevAttrReserved93 = 93
+        cudaDevAttrReserved94 = 94
+        cudaDevAttrCooperativeLaunch = 95
+        cudaDevAttrCooperativeMultiDeviceLaunch = 96
+        cudaDevAttrMaxSharedMemoryPerBlockOptin = 97
+        cudaDevAttrCanFlushRemoteWrites = 98
+        cudaDevAttrHostRegisterSupported = 99
+        cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100
+        cudaDevAttrDirectManagedMemAccessFromHost = 101
+        cudaDevAttrMaxBlocksPerMultiprocessor = 106
+        cudaDevAttrMaxPersistingL2CacheSize = 108
+        cudaDevAttrMaxAccessPolicyWindowSize = 109
+        cudaDevAttrReservedSharedMemoryPerBlock = 111
+        cudaDevAttrSparseCudaArraySupported = 112
+        cudaDevAttrHostRegisterReadOnlySupported = 113
+        cudaDevAttrTimelineSemaphoreInteropSupported = 114
+        cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114
+        cudaDevAttrMemoryPoolsSupported = 115
+        cudaDevAttrGPUDirectRDMASupported = 116
+        cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117
+        cudaDevAttrGPUDirectRDMAWritesOrdering = 118
+        cudaDevAttrMemoryPoolSupportedHandleTypes = 119
+        cudaDevAttrClusterLaunch = 120
+        cudaDevAttrDeferredMappingCudaArraySupported = 121
+        cudaDevAttrReserved122 = 122
+        cudaDevAttrReserved123 = 123
+        cudaDevAttrReserved124 = 124
+        cudaDevAttrIpcEventSupport = 125
+        cudaDevAttrMemSyncDomainCount = 126
+        cudaDevAttrReserved127 = 127
+        cudaDevAttrReserved128 = 128
+        cudaDevAttrReserved129 = 129
+        cudaDevAttrNumaConfig = 130
+        cudaDevAttrNumaId = 131
+        cudaDevAttrReserved132 = 132
+        cudaDevAttrMpsEnabled = 133
+        cudaDevAttrHostNumaId = 134
+        cudaDevAttrD3D12CigSupported = 135
+        cudaDevAttrVulkanCigSupported = 138
+        cudaDevAttrGpuPciDeviceId = 139
+        cudaDevAttrGpuPciSubsystemId = 140
+        cudaDevAttrReserved141 = 141
+        cudaDevAttrHostNumaMemoryPoolsSupported = 142
+        cudaDevAttrHostNumaMultinodeIpcSupported = 143
+        cudaDevAttrMax = 144
+
+    cdef enum cudaMemPoolAttr:
+        cudaMemPoolReuseFollowEventDependencies = 1
+        cudaMemPoolReuseAllowOpportunistic = 2
+        cudaMemPoolReuseAllowInternalDependencies = 3
+        cudaMemPoolAttrReleaseThreshold = 4
+        cudaMemPoolAttrReservedMemCurrent = 5
+        cudaMemPoolAttrReservedMemHigh = 6
+        cudaMemPoolAttrUsedMemCurrent = 7
+        cudaMemPoolAttrUsedMemHigh = 8
+
+    cdef enum cudaMemLocationType:
+        cudaMemLocationTypeInvalid = 0
+        cudaMemLocationTypeDevice = 1
+        cudaMemLocationTypeHost = 2
+        cudaMemLocationTypeHostNuma = 3
+        cudaMemLocationTypeHostNumaCurrent = 4
+
+    cdef enum cudaMemAccessFlags:
+        cudaMemAccessFlagsProtNone = 0
+        cudaMemAccessFlagsProtRead = 1
+        cudaMemAccessFlagsProtReadWrite = 3
+
+    cdef enum cudaMemAllocationType:
+        cudaMemAllocationTypeInvalid = 0
+        cudaMemAllocationTypePinned = 1
+        cudaMemAllocationTypeMax = 2147483647
+
+    cdef enum cudaMemAllocationHandleType:
+        cudaMemHandleTypeNone = 0
+        cudaMemHandleTypePosixFileDescriptor = 1
+        cudaMemHandleTypeWin32 = 2
+        cudaMemHandleTypeWin32Kmt = 4
+        cudaMemHandleTypeFabric = 8
+
+    cdef enum cudaGraphMemAttributeType:
+        cudaGraphMemAttrUsedMemCurrent = 0
+        cudaGraphMemAttrUsedMemHigh = 1
+        cudaGraphMemAttrReservedMemCurrent = 2
+        cudaGraphMemAttrReservedMemHigh = 3
+
+    cdef enum cudaMemcpyFlags:
+        cudaMemcpyFlagDefault = 0
+        cudaMemcpyFlagPreferOverlapWithCompute = 1
+
+    cdef enum cudaMemcpySrcAccessOrder:
+        cudaMemcpySrcAccessOrderInvalid = 0
+        cudaMemcpySrcAccessOrderStream = 1
+        cudaMemcpySrcAccessOrderDuringApiCall = 2
+        cudaMemcpySrcAccessOrderAny = 3
+        cudaMemcpySrcAccessOrderMax = 2147483647
+
+    cdef enum cudaMemcpy3DOperandType:
+        cudaMemcpyOperandTypePointer = 1
+        cudaMemcpyOperandTypeArray = 2
+        cudaMemcpyOperandTypeMax = 2147483647
+
+    cdef enum cudaDeviceP2PAttr:
+        cudaDevP2PAttrPerformanceRank = 1
+        cudaDevP2PAttrAccessSupported = 2
+        cudaDevP2PAttrNativeAtomicSupported = 3
+        cudaDevP2PAttrCudaArrayAccessSupported = 4
+
+    cdef enum cudaExternalMemoryHandleType:
+        cudaExternalMemoryHandleTypeOpaqueFd = 1
+        cudaExternalMemoryHandleTypeOpaqueWin32 = 2
+        cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3
+        cudaExternalMemoryHandleTypeD3D12Heap = 4
+        cudaExternalMemoryHandleTypeD3D12Resource = 5
+        cudaExternalMemoryHandleTypeD3D11Resource = 6
+        cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7
+        cudaExternalMemoryHandleTypeNvSciBuf = 8
+
+    cdef enum cudaExternalSemaphoreHandleType:
+        cudaExternalSemaphoreHandleTypeOpaqueFd = 1
+        cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2
+        cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3
+        cudaExternalSemaphoreHandleTypeD3D12Fence = 4
+        cudaExternalSemaphoreHandleTypeD3D11Fence = 5
+        cudaExternalSemaphoreHandleTypeNvSciSync = 6
+        cudaExternalSemaphoreHandleTypeKeyedMutex = 7
+        cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8
+        cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9
+        cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10
+
+    cdef enum cudaJitOption:
+        cudaJitMaxRegisters = 0
+        cudaJitThreadsPerBlock = 1
+        cudaJitWallTime = 2
+        cudaJitInfoLogBuffer = 3
+        cudaJitInfoLogBufferSizeBytes = 4
+        cudaJitErrorLogBuffer = 5
+        cudaJitErrorLogBufferSizeBytes = 6
+        cudaJitOptimizationLevel = 7
+        cudaJitFallbackStrategy = 10
+        cudaJitGenerateDebugInfo = 11
+        cudaJitLogVerbose = 12
+        cudaJitGenerateLineInfo = 13
+        cudaJitCacheMode = 14
+        cudaJitPositionIndependentCode = 30
+        cudaJitMinCtaPerSm = 31
+        cudaJitMaxThreadsPerBlock = 32
+        cudaJitOverrideDirectiveValues = 33
+
+    cdef enum cudaLibraryOption:
+        cudaLibraryHostUniversalFunctionAndDataTable = 0
+        cudaLibraryBinaryIsPreserved = 1
+
+    cdef enum cudaJit_CacheMode:
+        cudaJitCacheOptionNone = 0
+        cudaJitCacheOptionCG = 1
+        cudaJitCacheOptionCA = 2
+
+    cdef enum cudaJit_Fallback:
+        cudaPreferPtx = 0
+        cudaPreferBinary = 1
+
+    cdef enum cudaCGScope:
+        cudaCGScopeInvalid = 0
+        cudaCGScopeGrid = 1
+        cudaCGScopeMultiGrid = 2
+
+    cdef enum cudaGraphConditionalHandleFlags:
+        cudaGraphCondAssignDefault = 1
+
+    cdef enum cudaGraphConditionalNodeType:
+        cudaGraphCondTypeIf = 0
+        cudaGraphCondTypeWhile = 1
+        cudaGraphCondTypeSwitch = 2
+
+    cdef enum cudaGraphNodeType:
+        cudaGraphNodeTypeKernel = 0
+        cudaGraphNodeTypeMemcpy = 1
+        cudaGraphNodeTypeMemset = 2
+        cudaGraphNodeTypeHost = 3
+        cudaGraphNodeTypeGraph = 4
+        cudaGraphNodeTypeEmpty = 5
+        cudaGraphNodeTypeWaitEvent = 6
+        cudaGraphNodeTypeEventRecord = 7
+        cudaGraphNodeTypeExtSemaphoreSignal = 8
+        cudaGraphNodeTypeExtSemaphoreWait = 9
+        cudaGraphNodeTypeMemAlloc = 10
+        cudaGraphNodeTypeMemFree = 11
+        cudaGraphNodeTypeConditional = 13
+        cudaGraphNodeTypeCount = 14
+
+    cdef enum cudaGraphChildGraphNodeOwnership:
+        cudaGraphChildGraphOwnershipClone = 0
+        cudaGraphChildGraphOwnershipMove = 1
+
+    cdef enum cudaGraphExecUpdateResult:
+        cudaGraphExecUpdateSuccess = 0
+        cudaGraphExecUpdateError = 1
+        cudaGraphExecUpdateErrorTopologyChanged = 2
+        cudaGraphExecUpdateErrorNodeTypeChanged = 3
+        cudaGraphExecUpdateErrorFunctionChanged = 4
+        cudaGraphExecUpdateErrorParametersChanged = 5
+        cudaGraphExecUpdateErrorNotSupported = 6
+        cudaGraphExecUpdateErrorUnsupportedFunctionChange = 7
+        cudaGraphExecUpdateErrorAttributesChanged = 8
+
+    cdef enum cudaGraphKernelNodeField:
+        cudaGraphKernelNodeFieldInvalid = 0
+        cudaGraphKernelNodeFieldGridDim = 1
+        cudaGraphKernelNodeFieldParam = 2
+        cudaGraphKernelNodeFieldEnabled = 3
+
+    cdef enum cudaGetDriverEntryPointFlags:
+        cudaEnableDefault = 0
+        cudaEnableLegacyStream = 1
+        cudaEnablePerThreadDefaultStream = 2
+
+    cdef enum cudaDriverEntryPointQueryResult:
+        cudaDriverEntryPointSuccess = 0
+        cudaDriverEntryPointSymbolNotFound = 1
+        cudaDriverEntryPointVersionNotSufficent = 2
+
+    cdef enum cudaGraphDebugDotFlags:
+        cudaGraphDebugDotFlagsVerbose = 1
+        cudaGraphDebugDotFlagsKernelNodeParams = 4
+        cudaGraphDebugDotFlagsMemcpyNodeParams = 8
+        cudaGraphDebugDotFlagsMemsetNodeParams = 16
+        cudaGraphDebugDotFlagsHostNodeParams = 32
+        cudaGraphDebugDotFlagsEventNodeParams = 64
+        cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 128
+        cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 256
+        cudaGraphDebugDotFlagsKernelNodeAttributes = 512
+        cudaGraphDebugDotFlagsHandles = 1024
+        cudaGraphDebugDotFlagsConditionalNodeParams = 32768
+
+    cdef enum cudaGraphInstantiateFlags:
+        cudaGraphInstantiateFlagAutoFreeOnLaunch = 1
+        cudaGraphInstantiateFlagUpload = 2
+        cudaGraphInstantiateFlagDeviceLaunch = 4
+        cudaGraphInstantiateFlagUseNodePriority = 8
+
+    cdef enum cudaDeviceNumaConfig:
+        cudaDeviceNumaConfigNone = 0
+        cudaDeviceNumaConfigNumaNode = 1
+
+cdef extern from "surface_types.h":
+
+    ctypedef unsigned long long cudaSurfaceObject_t
+
+    cdef enum cudaSurfaceBoundaryMode:
+        cudaBoundaryModeZero = 0
+        cudaBoundaryModeClamp = 1
+        cudaBoundaryModeTrap = 2
+
+    cdef enum cudaSurfaceFormatMode:
+        cudaFormatModeForced = 0
+        cudaFormatModeAuto = 1
+
+cdef extern from "texture_types.h":
+
+    cdef struct cudaTextureDesc:
+        cudaTextureAddressMode addressMode[3]
+        cudaTextureFilterMode filterMode
+        cudaTextureReadMode readMode
+        int sRGB
+        float borderColor[4]
+        int normalizedCoords
+        unsigned int maxAnisotropy
+        cudaTextureFilterMode mipmapFilterMode
+        float mipmapLevelBias
+        float minMipmapLevelClamp
+        float maxMipmapLevelClamp
+        int disableTrilinearOptimization
+        int seamlessCubemap
+
+    ctypedef unsigned long long cudaTextureObject_t
+
+    cdef enum cudaTextureAddressMode:
+        cudaAddressModeWrap = 0
+        cudaAddressModeClamp = 1
+        cudaAddressModeMirror = 2
+        cudaAddressModeBorder = 3
+
+    cdef enum cudaTextureFilterMode:
+        cudaFilterModePoint = 0
+        cudaFilterModeLinear = 1
+
+    cdef enum cudaTextureReadMode:
+        cudaReadModeElementType = 0
+        cudaReadModeNormalizedFloat = 1
+
+cdef extern from "library_types.h":
+
+    cdef enum cudaDataType_t:
+        CUDA_R_32F = 0
+        CUDA_R_64F = 1
+        CUDA_R_16F = 2
+        CUDA_R_8I = 3
+        CUDA_C_32F = 4
+        CUDA_C_64F = 5
+        CUDA_C_16F = 6
+        CUDA_C_8I = 7
+        CUDA_R_8U = 8
+        CUDA_C_8U = 9
+        CUDA_R_32I = 10
+        CUDA_C_32I = 11
+        CUDA_R_32U = 12
+        CUDA_C_32U = 13
+        CUDA_R_16BF = 14
+        CUDA_C_16BF = 15
+        CUDA_R_4I = 16
+        CUDA_C_4I = 17
+        CUDA_R_4U = 18
+        CUDA_C_4U = 19
+        CUDA_R_16I = 20
+        CUDA_C_16I = 21
+        CUDA_R_16U = 22
+        CUDA_C_16U = 23
+        CUDA_R_64I = 24
+        CUDA_C_64I = 25
+        CUDA_R_64U = 26
+        CUDA_C_64U = 27
+        CUDA_R_8F_E4M3 = 28
+        CUDA_R_8F_UE4M3 = 28
+        CUDA_R_8F_E5M2 = 29
+        CUDA_R_8F_UE8M0 = 30
+        CUDA_R_6F_E2M3 = 31
+        CUDA_R_6F_E3M2 = 32
+        CUDA_R_4F_E2M1 = 33
+
+    ctypedef cudaDataType_t cudaDataType
+
+    cdef enum libraryPropertyType_t:
+        MAJOR_VERSION = 0
+        MINOR_VERSION = 1
+        PATCH_LEVEL = 2
+
+    ctypedef libraryPropertyType_t libraryPropertyType
+
+cdef extern from "cuda_runtime_api.h":
+
+    ctypedef void (*cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void* userData)
+
+cdef extern from "device_types.h":
+
+    cdef enum cudaRoundMode:
+        cudaRoundNearest = 0
+        cudaRoundZero = 1
+        cudaRoundPosInf = 2
+        cudaRoundMinInf = 3
+
+ctypedef cudaLaunchAttributeID cudaStreamAttrID
+
+ctypedef cudaLaunchAttributeID cudaKernelNodeAttrID
+
+ctypedef cudaLaunchAttributeValue cudaStreamAttrValue
+
+ctypedef cudaLaunchAttributeValue cudaKernelNodeAttrValue

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/nvjitlink.pxd

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.0.1 to 12.9.1. Do not modify it directly.
+
+from libc.stdint cimport intptr_t, uint32_t
+
+from .cynvjitlink cimport *
+
+
+###############################################################################
+# Types
+###############################################################################
+
+ctypedef nvJitLinkHandle Handle
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+ctypedef nvJitLinkResult _Result
+ctypedef nvJitLinkInputType _InputType
+
+
+###############################################################################
+# Functions
+###############################################################################
+
+cpdef intptr_t create(uint32_t num_options, options) except -1
+cpdef add_data(intptr_t handle, int input_type, data, size_t size, name)
+cpdef add_file(intptr_t handle, int input_type, file_name)
+cpdef complete(intptr_t handle)
+cpdef size_t get_linked_cubin_size(intptr_t handle) except? 0
+cpdef get_linked_cubin(intptr_t handle, cubin)
+cpdef size_t get_linked_ptx_size(intptr_t handle) except? 0
+cpdef get_linked_ptx(intptr_t handle, ptx)
+cpdef size_t get_error_log_size(intptr_t handle) except? 0
+cpdef get_error_log(intptr_t handle, log)
+cpdef size_t get_info_log_size(intptr_t handle) except? 0
+cpdef get_info_log(intptr_t handle, log)
+cpdef tuple version()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/nvrtc.pxd

@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# This code was automatically generated with version 12.9.0. Do not modify it directly.
+cimport cuda.bindings.cynvrtc as cynvrtc
+
+include "_lib/utils.pxd"
+
+cdef class nvrtcProgram:
+    """ nvrtcProgram is the unit of compilation, and an opaque handle for a program.
+
+    To compile a CUDA program string, an instance of nvrtcProgram must be created first with nvrtcCreateProgram, then compiled with nvrtcCompileProgram.
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    cdef cynvrtc.nvrtcProgram  _pvt_val
+    cdef cynvrtc.nvrtcProgram* _pvt_ptr

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/nvrtc.pyx

@@ -0,0 +1,1021 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+# This code was automatically generated with version 12.9.0. Do not modify it directly.
+from typing import Any, Optional
+from enum import IntEnum
+import cython
+import ctypes
+from libc.stdlib cimport calloc, malloc, free
+from libc cimport string
+from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t, uintptr_t
+from libc.stddef cimport wchar_t
+from libc.limits cimport CHAR_MIN
+from libcpp.vector cimport vector
+from cpython.buffer cimport PyObject_CheckBuffer, PyObject_GetBuffer, PyBuffer_Release, PyBUF_SIMPLE, PyBUF_ANY_CONTIGUOUS
+from cpython.bytes cimport PyBytes_FromStringAndSize
+
+import cuda.bindings.driver as _driver
+_driver = _driver.__dict__
+include "_lib/utils.pxi"
+
+ctypedef unsigned long long signed_char_ptr
+ctypedef unsigned long long unsigned_char_ptr
+ctypedef unsigned long long char_ptr
+ctypedef unsigned long long short_ptr
+ctypedef unsigned long long unsigned_short_ptr
+ctypedef unsigned long long int_ptr
+ctypedef unsigned long long long_int_ptr
+ctypedef unsigned long long long_long_int_ptr
+ctypedef unsigned long long unsigned_int_ptr
+ctypedef unsigned long long unsigned_long_int_ptr
+ctypedef unsigned long long unsigned_long_long_int_ptr
+ctypedef unsigned long long uint32_t_ptr
+ctypedef unsigned long long uint64_t_ptr
+ctypedef unsigned long long int32_t_ptr
+ctypedef unsigned long long int64_t_ptr
+ctypedef unsigned long long unsigned_ptr
+ctypedef unsigned long long unsigned_long_long_ptr
+ctypedef unsigned long long long_long_ptr
+ctypedef unsigned long long size_t_ptr
+ctypedef unsigned long long long_ptr
+ctypedef unsigned long long float_ptr
+ctypedef unsigned long long double_ptr
+ctypedef unsigned long long void_ptr
+
+
+class nvrtcResult(IntEnum):
+    """
+    The enumerated type nvrtcResult defines API call result codes.
+    NVRTC API functions return nvrtcResult to indicate the call result.
+    """
+    NVRTC_SUCCESS = cynvrtc.nvrtcResult.NVRTC_SUCCESS
+    NVRTC_ERROR_OUT_OF_MEMORY = cynvrtc.nvrtcResult.NVRTC_ERROR_OUT_OF_MEMORY
+    NVRTC_ERROR_PROGRAM_CREATION_FAILURE = cynvrtc.nvrtcResult.NVRTC_ERROR_PROGRAM_CREATION_FAILURE
+    NVRTC_ERROR_INVALID_INPUT = cynvrtc.nvrtcResult.NVRTC_ERROR_INVALID_INPUT
+    NVRTC_ERROR_INVALID_PROGRAM = cynvrtc.nvrtcResult.NVRTC_ERROR_INVALID_PROGRAM
+    NVRTC_ERROR_INVALID_OPTION = cynvrtc.nvrtcResult.NVRTC_ERROR_INVALID_OPTION
+    NVRTC_ERROR_COMPILATION = cynvrtc.nvrtcResult.NVRTC_ERROR_COMPILATION
+    NVRTC_ERROR_BUILTIN_OPERATION_FAILURE = cynvrtc.nvrtcResult.NVRTC_ERROR_BUILTIN_OPERATION_FAILURE
+    NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION = cynvrtc.nvrtcResult.NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION
+    NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION = cynvrtc.nvrtcResult.NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION
+    NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID = cynvrtc.nvrtcResult.NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID
+    NVRTC_ERROR_INTERNAL_ERROR = cynvrtc.nvrtcResult.NVRTC_ERROR_INTERNAL_ERROR
+    NVRTC_ERROR_TIME_FILE_WRITE_FAILED = cynvrtc.nvrtcResult.NVRTC_ERROR_TIME_FILE_WRITE_FAILED
+    NVRTC_ERROR_NO_PCH_CREATE_ATTEMPTED = cynvrtc.nvrtcResult.NVRTC_ERROR_NO_PCH_CREATE_ATTEMPTED
+    NVRTC_ERROR_PCH_CREATE_HEAP_EXHAUSTED = cynvrtc.nvrtcResult.NVRTC_ERROR_PCH_CREATE_HEAP_EXHAUSTED
+    NVRTC_ERROR_PCH_CREATE = cynvrtc.nvrtcResult.NVRTC_ERROR_PCH_CREATE
+    NVRTC_ERROR_CANCELLED = cynvrtc.nvrtcResult.NVRTC_ERROR_CANCELLED
+
+_dict_nvrtcResult = dict(((int(v), v) for k, v in nvrtcResult.__members__.items()))
+
+cdef class nvrtcProgram:
+    """ nvrtcProgram is the unit of compilation, and an opaque handle for a program.
+
+    To compile a CUDA program string, an instance of nvrtcProgram must be created first with nvrtcCreateProgram, then compiled with nvrtcCompileProgram.
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
+        if _ptr == 0:
+            self._pvt_ptr = &self._pvt_val
+            self._pvt_ptr[0] = <cynvrtc.nvrtcProgram>init_value
+        else:
+            self._pvt_ptr = <cynvrtc.nvrtcProgram *>_ptr
+    def __init__(self, *args, **kwargs):
+        pass
+    def __repr__(self):
+        return '<nvrtcProgram ' + str(hex(self.__int__())) + '>'
+    def __index__(self):
+        return self.__int__()
+    def __eq__(self, other):
+        if not isinstance(other, nvrtcProgram):
+            return False
+        return self._pvt_ptr[0] == (<nvrtcProgram>other)._pvt_ptr[0]
+    def __hash__(self):
+        return hash(<uintptr_t><void*>(self._pvt_ptr[0]))
+    def __int__(self):
+        return <void_ptr>self._pvt_ptr[0]
+    def getPtr(self):
+        return <void_ptr>self._pvt_ptr
+
+@cython.embedsignature(True)
+def nvrtcGetErrorString(result not None : nvrtcResult):
+    """ nvrtcGetErrorString is a helper function that returns a string describing the given nvrtcResult code, e.g., NVRTC_SUCCESS to `"NVRTC_SUCCESS"`. For unrecognized enumeration values, it returns `"NVRTC_ERROR unknown"`.
+
+    Parameters
+    ----------
+    result : :py:obj:`~.nvrtcResult`
+        CUDA Runtime Compilation API result code.
+
+    Returns
+    -------
+    nvrtcResult.NVRTC_SUCCESS
+        nvrtcResult.NVRTC_SUCCESS
+    bytes
+        Message string for the given :py:obj:`~.nvrtcResult` code.
+    """
+    cdef cynvrtc.nvrtcResult cyresult = result.value
+    with nogil:
+        err = cynvrtc.nvrtcGetErrorString(cyresult)
+    return (nvrtcResult.NVRTC_SUCCESS, err)
+
+@cython.embedsignature(True)
+def nvrtcVersion():
+    """ nvrtcVersion sets the output parameters `major` and `minor` with the CUDA Runtime Compilation version number.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+    major : int
+        CUDA Runtime Compilation major version number.
+    minor : int
+        CUDA Runtime Compilation minor version number.
+    """
+    cdef int major = 0
+    cdef int minor = 0
+    with nogil:
+        err = cynvrtc.nvrtcVersion(&major, &minor)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None, None)
+    return (_dict_nvrtcResult[err], major, minor)
+
+@cython.embedsignature(True)
+def nvrtcGetNumSupportedArchs():
+    """ nvrtcGetNumSupportedArchs sets the output parameter `numArchs` with the number of architectures supported by NVRTC. This can then be used to pass an array to :py:obj:`~.nvrtcGetSupportedArchs` to get the supported architectures.
+
+    see :py:obj:`~.nvrtcGetSupportedArchs`
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+    numArchs : int
+        number of supported architectures.
+    """
+    cdef int numArchs = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetNumSupportedArchs(&numArchs)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], numArchs)
+
+@cython.embedsignature(True)
+def nvrtcGetSupportedArchs():
+    """ nvrtcGetSupportedArchs populates the array passed via the output parameter `supportedArchs` with the architectures supported by NVRTC. The array is sorted in the ascending order. The size of the array to be passed can be determined using :py:obj:`~.nvrtcGetNumSupportedArchs`.
+
+    see :py:obj:`~.nvrtcGetNumSupportedArchs`
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+    supportedArchs : list[int]
+        sorted array of supported architectures.
+    """
+    cdef vector[int] supportedArchs
+    _, s = nvrtcGetNumSupportedArchs()
+    supportedArchs.resize(s)
+
+    with nogil:
+        err = cynvrtc.nvrtcGetSupportedArchs(supportedArchs.data())
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], supportedArchs)
+
+@cython.embedsignature(True)
+def nvrtcCreateProgram(char* src, char* name, int numHeaders, headers : Optional[tuple[bytes] | list[bytes]], includeNames : Optional[tuple[bytes] | list[bytes]]):
+    """ nvrtcCreateProgram creates an instance of nvrtcProgram with the given input parameters, and sets the output parameter `prog` with it.
+
+    Parameters
+    ----------
+    src : bytes
+        CUDA program source.
+    name : bytes
+        CUDA program name.  `name` can be `NULL`; `"default_program"` is
+        used when `name` is `NULL` or "".
+    numHeaders : int
+        Number of headers used.  `numHeaders` must be greater than or equal
+        to 0.
+    headers : list[bytes]
+        Sources of the headers.  `headers` can be `NULL` when `numHeaders`
+        is 0.
+    includeNames : list[bytes]
+        Name of each header by which they can be included in the CUDA
+        program source.  `includeNames` can be `NULL` when `numHeaders` is
+        0. These headers must be included with the exact names specified
+        here.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_OUT_OF_MEMORY`
+        - :py:obj:`~.NVRTC_ERROR_PROGRAM_CREATION_FAILURE`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcDestroyProgram`
+    """
+    includeNames = [] if includeNames is None else includeNames
+    if not all(isinstance(_x, (bytes)) for _x in includeNames):
+        raise TypeError("Argument 'includeNames' is not instance of type (expected tuple[bytes] or list[bytes]")
+    headers = [] if headers is None else headers
+    if not all(isinstance(_x, (bytes)) for _x in headers):
+        raise TypeError("Argument 'headers' is not instance of type (expected tuple[bytes] or list[bytes]")
+    cdef nvrtcProgram prog = nvrtcProgram()
+    if numHeaders > len(headers): raise RuntimeError("List is too small: " + str(len(headers)) + " < " + str(numHeaders))
+    if numHeaders > len(includeNames): raise RuntimeError("List is too small: " + str(len(includeNames)) + " < " + str(numHeaders))
+    cdef vector[const char*] cyheaders = headers
+    cdef vector[const char*] cyincludeNames = includeNames
+    with nogil:
+        err = cynvrtc.nvrtcCreateProgram(<cynvrtc.nvrtcProgram*>prog._pvt_ptr, src, name, numHeaders, cyheaders.data(), cyincludeNames.data())
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], prog)
+
+@cython.embedsignature(True)
+def nvrtcDestroyProgram(prog):
+    """ nvrtcDestroyProgram destroys the given program.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcCreateProgram`
+    """
+    cdef cynvrtc.nvrtcProgram *cyprog
+    if prog is None:
+        cyprog = <cynvrtc.nvrtcProgram*><void_ptr>NULL
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = prog.getPtr()
+        cyprog = <cynvrtc.nvrtcProgram*><void_ptr>pprog
+    elif isinstance(prog, (int)):
+        cyprog = <cynvrtc.nvrtcProgram*><void_ptr>prog
+    else:
+        raise TypeError("Argument 'prog' is not instance of type (expected <class 'int, nvrtc.nvrtcProgram'>, found " + str(type(prog)))
+    with nogil:
+        err = cynvrtc.nvrtcDestroyProgram(cyprog)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcCompileProgram(prog, int numOptions, options : Optional[tuple[bytes] | list[bytes]]):
+    """ nvrtcCompileProgram compiles the given program.
+
+    It supports compile options listed in :py:obj:`~.Supported Compile
+    Options`.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+    numOptions : int
+        Number of compiler options passed.
+    options : list[bytes]
+        Compiler options in the form of C string array.  `options` can be
+        `NULL` when `numOptions` is 0.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_OUT_OF_MEMORY`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_OPTION`
+        - :py:obj:`~.NVRTC_ERROR_COMPILATION`
+        - :py:obj:`~.NVRTC_ERROR_BUILTIN_OPERATION_FAILURE`
+        - :py:obj:`~.NVRTC_ERROR_TIME_FILE_WRITE_FAILED`
+        - :py:obj:`~.NVRTC_ERROR_CANCELLED`
+    """
+    options = [] if options is None else options
+    if not all(isinstance(_x, (bytes)) for _x in options):
+        raise TypeError("Argument 'options' is not instance of type (expected tuple[bytes] or list[bytes]")
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    if numOptions > len(options): raise RuntimeError("List is too small: " + str(len(options)) + " < " + str(numOptions))
+    cdef vector[const char*] cyoptions = options
+    with nogil:
+        err = cynvrtc.nvrtcCompileProgram(cyprog, numOptions, cyoptions.data())
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetPTXSize(prog):
+    """ nvrtcGetPTXSize sets the value of `ptxSizeRet` with the size of the PTX generated by the previous compilation of `prog` (including the trailing `NULL`).
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+    ptxSizeRet : int
+        Size of the generated PTX (including the trailing `NULL`).
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetPTX`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cdef size_t ptxSizeRet = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetPTXSize(cyprog, &ptxSizeRet)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], ptxSizeRet)
+
+@cython.embedsignature(True)
+def nvrtcGetPTX(prog, char* ptx):
+    """ nvrtcGetPTX stores the PTX generated by the previous compilation of `prog` in the memory pointed by `ptx`.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+    ptx : bytes
+        Compiled result.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetPTXSize`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    with nogil:
+        err = cynvrtc.nvrtcGetPTX(cyprog, ptx)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetCUBINSize(prog):
+    """ nvrtcGetCUBINSize sets the value of `cubinSizeRet` with the size of the cubin generated by the previous compilation of `prog`. The value of cubinSizeRet is set to 0 if the value specified to `-arch` is a virtual architecture instead of an actual architecture.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+    cubinSizeRet : int
+        Size of the generated cubin.
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetCUBIN`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cdef size_t cubinSizeRet = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetCUBINSize(cyprog, &cubinSizeRet)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], cubinSizeRet)
+
+@cython.embedsignature(True)
+def nvrtcGetCUBIN(prog, char* cubin):
+    """ nvrtcGetCUBIN stores the cubin generated by the previous compilation of `prog` in the memory pointed by `cubin`. No cubin is available if the value specified to `-arch` is a virtual architecture instead of an actual architecture.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+    cubin : bytes
+        Compiled and assembled result.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetCUBINSize`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    with nogil:
+        err = cynvrtc.nvrtcGetCUBIN(cyprog, cubin)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetNVVMSize(prog):
+    """ DEPRECATION NOTICE: This function will be removed in a future release. Please use nvrtcGetLTOIRSize (and nvrtcGetLTOIR) instead.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        None
+
+    Returns
+    -------
+    nvrtcResult
+
+    nvvmSizeRet : int
+        None
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cdef size_t nvvmSizeRet = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetNVVMSize(cyprog, &nvvmSizeRet)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], nvvmSizeRet)
+
+@cython.embedsignature(True)
+def nvrtcGetNVVM(prog, char* nvvm):
+    """ DEPRECATION NOTICE: This function will be removed in a future release. Please use nvrtcGetLTOIR (and nvrtcGetLTOIRSize) instead.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        None
+    nvvm : bytes
+        None
+
+    Returns
+    -------
+    nvrtcResult
+
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    with nogil:
+        err = cynvrtc.nvrtcGetNVVM(cyprog, nvvm)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetLTOIRSize(prog):
+    """ nvrtcGetLTOIRSize sets the value of `LTOIRSizeRet` with the size of the LTO IR generated by the previous compilation of `prog`. The value of LTOIRSizeRet is set to 0 if the program was not compiled with `-dlto`.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+    LTOIRSizeRet : int
+        Size of the generated LTO IR.
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetLTOIR`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cdef size_t LTOIRSizeRet = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetLTOIRSize(cyprog, &LTOIRSizeRet)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], LTOIRSizeRet)
+
+@cython.embedsignature(True)
+def nvrtcGetLTOIR(prog, char* LTOIR):
+    """ nvrtcGetLTOIR stores the LTO IR generated by the previous compilation of `prog` in the memory pointed by `LTOIR`. No LTO IR is available if the program was compiled without `-dlto`.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+    LTOIR : bytes
+        Compiled result.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetLTOIRSize`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    with nogil:
+        err = cynvrtc.nvrtcGetLTOIR(cyprog, LTOIR)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetOptiXIRSize(prog):
+    """ nvrtcGetOptiXIRSize sets the value of `optixirSizeRet` with the size of the OptiX IR generated by the previous compilation of `prog`. The value of nvrtcGetOptiXIRSize is set to 0 if the program was compiled with options incompatible with OptiX IR generation.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+    optixirSizeRet : int
+        Size of the generated LTO IR.
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetOptiXIR`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cdef size_t optixirSizeRet = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetOptiXIRSize(cyprog, &optixirSizeRet)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], optixirSizeRet)
+
+@cython.embedsignature(True)
+def nvrtcGetOptiXIR(prog, char* optixir):
+    """ nvrtcGetOptiXIR stores the OptiX IR generated by the previous compilation of `prog` in the memory pointed by `optixir`. No OptiX IR is available if the program was compiled with options incompatible with OptiX IR generation.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+    optixir : bytes
+        Optix IR Compiled result.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetOptiXIRSize`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    with nogil:
+        err = cynvrtc.nvrtcGetOptiXIR(cyprog, optixir)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetProgramLogSize(prog):
+    """ nvrtcGetProgramLogSize sets `logSizeRet` with the size of the log generated by the previous compilation of `prog` (including the trailing `NULL`).
+
+    Note that compilation log may be generated with warnings and
+    informative messages, even when the compilation of `prog` succeeds.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+    logSizeRet : int
+        Size of the compilation log (including the trailing `NULL`).
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetProgramLog`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cdef size_t logSizeRet = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetProgramLogSize(cyprog, &logSizeRet)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], logSizeRet)
+
+@cython.embedsignature(True)
+def nvrtcGetProgramLog(prog, char* log):
+    """ nvrtcGetProgramLog stores the log generated by the previous compilation of `prog` in the memory pointed by `log`.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+    log : bytes
+        Compilation log.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetProgramLogSize`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    with nogil:
+        err = cynvrtc.nvrtcGetProgramLog(cyprog, log)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcAddNameExpression(prog, char* name_expression):
+    """ nvrtcAddNameExpression notes the given name expression denoting the address of a global function or device/__constant__ variable.
+
+    The identical name expression string must be provided on a subsequent
+    call to nvrtcGetLoweredName to extract the lowered name.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+    name_expression : bytes
+        constant expression denoting the address of a global function or
+        device/__constant__ variable.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+        - :py:obj:`~.NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION`
+
+    See Also
+    --------
+    :py:obj:`~.nvrtcGetLoweredName`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    with nogil:
+        err = cynvrtc.nvrtcAddNameExpression(cyprog, name_expression)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetLoweredName(prog, char* name_expression):
+    """ nvrtcGetLoweredName extracts the lowered (mangled) name for a global function or device/__constant__ variable, and updates lowered_name to point to it. The memory containing the name is released when the NVRTC program is destroyed by nvrtcDestroyProgram. The identical name expression must have been previously provided to nvrtcAddNameExpression.
+
+    Parameters
+    ----------
+    prog : nvrtcProgram
+        CUDA Runtime Compilation program.
+    name_expression : bytes
+        constant expression denoting the address of a global function or
+        device/__constant__ variable.
+
+    Returns
+    -------
+    nvrtcResult
+        NVRTC_SUCCESS
+        NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION
+        NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID
+    lowered_name : bytes
+        initialized by the function to point to a C string containing the
+        lowered (mangled) name corresponding to the provided name
+        expression.
+
+    See Also
+    --------
+    nvrtcAddNameExpression
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cdef const char* lowered_name = NULL
+    with nogil:
+        err = cynvrtc.nvrtcGetLoweredName(cyprog, name_expression, &lowered_name)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], <bytes>lowered_name if lowered_name != NULL else None)
+
+@cython.embedsignature(True)
+def nvrtcGetPCHHeapSize():
+    """ retrieve the current size of the PCH Heap.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+    ret : int
+        pointer to location where the size of the PCH Heap will be stored
+    """
+    cdef size_t ret = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetPCHHeapSize(&ret)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], ret)
+
+@cython.embedsignature(True)
+def nvrtcSetPCHHeapSize(size_t size):
+    """ set the size of the PCH Heap.
+
+    The requested size may be rounded up to a platform dependent alignment
+    (e.g. page size). If the PCH Heap has already been allocated, the heap
+    memory will be freed and a new PCH Heap will be allocated.
+
+    Parameters
+    ----------
+    size : size_t
+        requested size of the PCH Heap, in bytes
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+    """
+    with nogil:
+        err = cynvrtc.nvrtcSetPCHHeapSize(size)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetPCHCreateStatus(prog):
+    """ returns the PCH creation status.
+
+    NVRTC_SUCCESS indicates that the PCH was successfully created.
+    NVRTC_ERROR_NO_PCH_CREATE_ATTEMPTED indicates that no PCH creation was
+    attempted, either because PCH functionality was not requested during
+    the preceding nvrtcCompileProgram call, or automatic PCH processing was
+    requested, and compiler chose not to create a PCH file.
+    NVRTC_ERROR_PCH_CREATE_HEAP_EXHAUSTED indicates that a PCH file could
+    potentially have been created, but the compiler ran out space in the
+    PCH heap. In this scenario, the
+    :py:obj:`~.nvrtcGetPCHHeapSizeRequired()` can be used to query the
+    required heap size, the heap can be reallocated for this size with
+    :py:obj:`~.nvrtcSetPCHHeapSize()` and PCH creation may be reattempted
+    again invoking :py:obj:`~.nvrtcCompileProgram()` with a new NVRTC
+    program instance. NVRTC_ERROR_PCH_CREATE indicates that an error
+    condition prevented the PCH file from being created.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_NO_PCH_CREATE_ATTEMPTED`
+        - :py:obj:`~.NVRTC_ERROR_PCH_CREATE`
+        - :py:obj:`~.NVRTC_ERROR_PCH_CREATE_HEAP_EXHAUSTED`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    with nogil:
+        err = cynvrtc.nvrtcGetPCHCreateStatus(cyprog)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def nvrtcGetPCHHeapSizeRequired(prog):
+    """ retrieve the required size of the PCH heap required to compile the given program.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT` The size retrieved using this function is only valid if :py:obj:`~.nvrtcGetPCHCreateStatus()` returned NVRTC_SUCCESS or NVRTC_ERROR_PCH_CREATE_HEAP_EXHAUSTED
+    size : int
+        pointer to location where the required size of the PCH Heap will be
+        stored
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cdef size_t size = 0
+    with nogil:
+        err = cynvrtc.nvrtcGetPCHHeapSizeRequired(cyprog, &size)
+    if err != cynvrtc.NVRTC_SUCCESS:
+        return (_dict_nvrtcResult[err], None)
+    return (_dict_nvrtcResult[err], size)
+
+@cython.embedsignature(True)
+def nvrtcSetFlowCallback(prog, callback, payload):
+    """ nvrtcSetFlowCallback registers a callback function that the compiler will invoke at different points during a call to nvrtcCompileProgram, and the callback function can decide whether to cancel compilation by returning specific values.
+
+    The callback function must satisfy the following constraints:
+
+    (1) Its signature should be:
+
+    **View CUDA Toolkit Documentation for a C++ code example**
+
+    When invoking the callback, the compiler will always pass `payload` to
+    param1 so that the callback may make decisions based on `payload` .
+    It'll always pass NULL to param2 for now which is reserved for future
+    extensions.
+
+    (2) It must return 1 to cancel compilation or 0 to continue. Other
+    return values are reserved for future use.
+
+    (3) It must return consistent values. Once it returns 1 at one point,
+    it must return 1 in all following invocations during the current
+    nvrtcCompileProgram call in progress.
+
+    (4) It must be thread-safe.
+
+    (5) It must not invoke any nvrtc/libnvvm/ptx APIs.
+
+    Parameters
+    ----------
+    prog : :py:obj:`~.nvrtcProgram`
+        CUDA Runtime Compilation program.
+    callback : Any
+        the callback that issues cancellation signal.
+    payload : Any
+        to be passed as a parameter when invoking the callback.
+
+    Returns
+    -------
+    nvrtcResult
+        - :py:obj:`~.NVRTC_SUCCESS`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_PROGRAM`
+        - :py:obj:`~.NVRTC_ERROR_INVALID_INPUT`
+    """
+    cdef cynvrtc.nvrtcProgram cyprog
+    if prog is None:
+        pprog = 0
+    elif isinstance(prog, (nvrtcProgram,)):
+        pprog = int(prog)
+    else:
+        pprog = int(nvrtcProgram(prog))
+    cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    cycallback = _HelperInputVoidPtr(callback)
+    cdef void* cycallback_ptr = <void*><void_ptr>cycallback.cptr
+    cypayload = _HelperInputVoidPtr(payload)
+    cdef void* cypayload_ptr = <void*><void_ptr>cypayload.cptr
+    with nogil:
+        err = cynvrtc.nvrtcSetFlowCallback(cyprog, cycallback_ptr, cypayload_ptr)
+    return (_dict_nvrtcResult[err],)
+
+@cython.embedsignature(True)
+def sizeof(objType):
+    """ Returns the size of provided CUDA Python structure in bytes
+
+    Parameters
+    ----------
+    objType : Any
+        CUDA Python object
+
+    Returns
+    -------
+    lowered_name : int
+        The size of `objType` in bytes
+    """
+    if objType == nvrtcProgram:
+        return sizeof(cynvrtc.nvrtcProgram)
+    raise TypeError("Unknown type: " + str(objType))

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/nvvm.pxd

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.0.1 to 12.9.1. Do not modify it directly.
+
+from libc.stdint cimport intptr_t
+
+from .cynvvm cimport *
+
+
+###############################################################################
+# Types
+###############################################################################
+
+ctypedef nvvmProgram Program
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+ctypedef nvvmResult _Result
+
+
+###############################################################################
+# Functions
+###############################################################################
+
+cpdef str get_error_string(int result)
+cpdef tuple version()
+cpdef tuple ir_version()
+cpdef intptr_t create_program() except? 0
+cpdef add_module_to_program(intptr_t prog, buffer, size_t size, name)
+cpdef lazy_add_module_to_program(intptr_t prog, buffer, size_t size, name)
+cpdef compile_program(intptr_t prog, int num_options, options)
+cpdef verify_program(intptr_t prog, int num_options, options)
+cpdef size_t get_compiled_result_size(intptr_t prog) except? 0
+cpdef get_compiled_result(intptr_t prog, buffer)
+cpdef size_t get_program_log_size(intptr_t prog) except? 0
+cpdef get_program_log(intptr_t prog, buffer)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/bindings/nvvm.pyx

@@ -0,0 +1,297 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.0.1 to 12.9.1. Do not modify it directly.
+
+cimport cython  # NOQA
+
+from ._internal.utils cimport (get_buffer_pointer, get_nested_resource_ptr,
+                               nested_resource)
+
+from enum import IntEnum as _IntEnum
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+class Result(_IntEnum):
+    """See `nvvmResult`."""
+    SUCCESS = NVVM_SUCCESS
+    ERROR_OUT_OF_MEMORY = NVVM_ERROR_OUT_OF_MEMORY
+    ERROR_PROGRAM_CREATION_FAILURE = NVVM_ERROR_PROGRAM_CREATION_FAILURE
+    ERROR_IR_VERSION_MISMATCH = NVVM_ERROR_IR_VERSION_MISMATCH
+    ERROR_INVALID_INPUT = NVVM_ERROR_INVALID_INPUT
+    ERROR_INVALID_PROGRAM = NVVM_ERROR_INVALID_PROGRAM
+    ERROR_INVALID_IR = NVVM_ERROR_INVALID_IR
+    ERROR_INVALID_OPTION = NVVM_ERROR_INVALID_OPTION
+    ERROR_NO_MODULE_IN_PROGRAM = NVVM_ERROR_NO_MODULE_IN_PROGRAM
+    ERROR_COMPILATION = NVVM_ERROR_COMPILATION
+    ERROR_CANCELLED = NVVM_ERROR_CANCELLED
+
+
+###############################################################################
+# Error handling
+###############################################################################
+
+class nvvmError(Exception):
+
+    def __init__(self, status):
+        self.status = status
+        s = Result(status)
+        cdef str err = f"{s.name} ({s.value})"
+        super(nvvmError, self).__init__(err)
+
+    def __reduce__(self):
+        return (type(self), (self.status,))
+
+
+@cython.profile(False)
+cdef int check_status(int status) except 1 nogil:
+    if status != 0:
+        with gil:
+            raise nvvmError(status)
+    return status
+
+
+###############################################################################
+# Wrapper functions
+###############################################################################
+
+cpdef destroy_program(intptr_t prog):
+    """Destroy a program.
+
+    Args:
+        prog (intptr_t): nvvm prog.
+
+    .. seealso:: `nvvmDestroyProgram`
+    """
+    cdef Program p = <Program>prog
+    with nogil:
+        status = nvvmDestroyProgram(&p)
+    check_status(status)
+
+
+cpdef str get_error_string(int result):
+    """Get the message string for the given ``nvvmResult`` code.
+
+    Args:
+        result (Result): NVVM API result code.
+
+    .. seealso:: `nvvmGetErrorString`
+    """
+    cdef bytes _output_
+    _output_ = nvvmGetErrorString(<_Result>result)
+    return _output_.decode()
+
+
+cpdef tuple version():
+    """Get the NVVM version.
+
+    Returns:
+        A 2-tuple containing:
+
+        - int: NVVM major version number.
+        - int: NVVM minor version number.
+
+    .. seealso:: `nvvmVersion`
+    """
+    cdef int major
+    cdef int minor
+    with nogil:
+        status = nvvmVersion(&major, &minor)
+    check_status(status)
+    return (major, minor)
+
+
+cpdef tuple ir_version():
+    """Get the NVVM IR version.
+
+    Returns:
+        A 4-tuple containing:
+
+        - int: NVVM IR major version number.
+        - int: NVVM IR minor version number.
+        - int: NVVM IR debug metadata major version number.
+        - int: NVVM IR debug metadata minor version number.
+
+    .. seealso:: `nvvmIRVersion`
+    """
+    cdef int major_ir
+    cdef int minor_ir
+    cdef int major_dbg
+    cdef int minor_dbg
+    with nogil:
+        status = nvvmIRVersion(&major_ir, &minor_ir, &major_dbg, &minor_dbg)
+    check_status(status)
+    return (major_ir, minor_ir, major_dbg, minor_dbg)
+
+
+cpdef intptr_t create_program() except? 0:
+    """Create a program, and set the value of its handle to ``*prog``.
+
+    Returns:
+        intptr_t: NVVM program.
+
+    .. seealso:: `nvvmCreateProgram`
+    """
+    cdef Program prog
+    with nogil:
+        status = nvvmCreateProgram(&prog)
+    check_status(status)
+    return <intptr_t>prog
+
+
+cpdef add_module_to_program(intptr_t prog, buffer, size_t size, name):
+    """Add a module level NVVM IR to a program.
+
+    Args:
+        prog (intptr_t): NVVM program.
+        buffer (bytes): NVVM IR module in the bitcode or text representation.
+        size (size_t): Size of the NVVM IR module.
+        name (str): Name of the NVVM IR module. If NULL, "<unnamed>" is used as the name.
+
+    .. seealso:: `nvvmAddModuleToProgram`
+    """
+    cdef void* _buffer_ = get_buffer_pointer(buffer, size, readonly=True)
+    if not isinstance(name, str):
+        raise TypeError("name must be a Python str")
+    cdef bytes _temp_name_ = (<str>name).encode()
+    cdef char* _name_ = _temp_name_
+    with nogil:
+        status = nvvmAddModuleToProgram(<Program>prog, <const char*>_buffer_, size, <const char*>_name_)
+    check_status(status)
+
+
+cpdef lazy_add_module_to_program(intptr_t prog, buffer, size_t size, name):
+    """Add a module level NVVM IR to a program.
+
+    Args:
+        prog (intptr_t): NVVM program.
+        buffer (bytes): NVVM IR module in the bitcode representation.
+        size (size_t): Size of the NVVM IR module.
+        name (str): Name of the NVVM IR module. If NULL, "<unnamed>" is used as the name.
+
+    .. seealso:: `nvvmLazyAddModuleToProgram`
+    """
+    cdef void* _buffer_ = get_buffer_pointer(buffer, size, readonly=True)
+    if not isinstance(name, str):
+        raise TypeError("name must be a Python str")
+    cdef bytes _temp_name_ = (<str>name).encode()
+    cdef char* _name_ = _temp_name_
+    with nogil:
+        status = nvvmLazyAddModuleToProgram(<Program>prog, <const char*>_buffer_, size, <const char*>_name_)
+    check_status(status)
+
+
+cpdef compile_program(intptr_t prog, int num_options, options):
+    """Compile the NVVM program.
+
+    Args:
+        prog (intptr_t): NVVM program.
+        num_options (int): Number of compiler ``options`` passed.
+        options (object): Compiler options in the form of C string array. It can be:
+
+            - an :class:`int` as the pointer address to the nested sequence, or
+            - a Python sequence of :class:`int`\s, each of which is a pointer address
+              to a valid sequence of 'char', or
+            - a nested Python sequence of ``str``.
+
+
+    .. seealso:: `nvvmCompileProgram`
+    """
+    cdef nested_resource[ char ] _options_
+    get_nested_resource_ptr[char](_options_, options, <char*>NULL)
+    with nogil:
+        status = nvvmCompileProgram(<Program>prog, num_options, <const char**>(_options_.ptrs.data()))
+    check_status(status)
+
+
+cpdef verify_program(intptr_t prog, int num_options, options):
+    """Verify the NVVM program.
+
+    Args:
+        prog (intptr_t): NVVM program.
+        num_options (int): Number of compiler ``options`` passed.
+        options (object): Compiler options in the form of C string array. It can be:
+
+            - an :class:`int` as the pointer address to the nested sequence, or
+            - a Python sequence of :class:`int`\s, each of which is a pointer address
+              to a valid sequence of 'char', or
+            - a nested Python sequence of ``str``.
+
+
+    .. seealso:: `nvvmVerifyProgram`
+    """
+    cdef nested_resource[ char ] _options_
+    get_nested_resource_ptr[char](_options_, options, <char*>NULL)
+    with nogil:
+        status = nvvmVerifyProgram(<Program>prog, num_options, <const char**>(_options_.ptrs.data()))
+    check_status(status)
+
+
+cpdef size_t get_compiled_result_size(intptr_t prog) except? 0:
+    """Get the size of the compiled result.
+
+    Args:
+        prog (intptr_t): NVVM program.
+
+    Returns:
+        size_t: Size of the compiled result (including the trailing NULL).
+
+    .. seealso:: `nvvmGetCompiledResultSize`
+    """
+    cdef size_t buffer_size_ret
+    with nogil:
+        status = nvvmGetCompiledResultSize(<Program>prog, &buffer_size_ret)
+    check_status(status)
+    return buffer_size_ret
+
+
+cpdef get_compiled_result(intptr_t prog, buffer):
+    """Get the compiled result.
+
+    Args:
+        prog (intptr_t): NVVM program.
+        buffer (bytes): Compiled result.
+
+    .. seealso:: `nvvmGetCompiledResult`
+    """
+    cdef void* _buffer_ = get_buffer_pointer(buffer, -1, readonly=False)
+    with nogil:
+        status = nvvmGetCompiledResult(<Program>prog, <char*>_buffer_)
+    check_status(status)
+
+
+cpdef size_t get_program_log_size(intptr_t prog) except? 0:
+    """Get the Size of Compiler/Verifier Message.
+
+    Args:
+        prog (intptr_t): NVVM program.
+
+    Returns:
+        size_t: Size of the compilation/verification log (including the trailing NULL).
+
+    .. seealso:: `nvvmGetProgramLogSize`
+    """
+    cdef size_t buffer_size_ret
+    with nogil:
+        status = nvvmGetProgramLogSize(<Program>prog, &buffer_size_ret)
+    check_status(status)
+    return buffer_size_ret
+
+
+cpdef get_program_log(intptr_t prog, buffer):
+    """Get the Compiler/Verifier Message.
+
+    Args:
+        prog (intptr_t): NVVM program.
+        buffer (bytes): Compilation/Verification log.
+
+    .. seealso:: `nvvmGetProgramLog`
+    """
+    cdef void* _buffer_ = get_buffer_pointer(buffer, -1, readonly=False)
+    with nogil:
+        status = nvvmGetProgramLog(<Program>prog, <char*>_buffer_)
+    check_status(status)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/pathfinder/README.md

@@ -0,0 +1,3 @@
+### The `cuda.pathfinder` documentation was moved
+
+Please see https://nvidia.github.io/cuda-python/cuda-pathfinder/latest/

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/pathfinder/__init__.py

@@ -0,0 +1,66 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""cuda.pathfinder public APIs"""
+
+from cuda.pathfinder._binaries.find_nvidia_binary_utility import (
+    find_nvidia_binary_utility as find_nvidia_binary_utility,
+)
+from cuda.pathfinder._binaries.supported_nvidia_binaries import SUPPORTED_BINARIES as _SUPPORTED_BINARIES
+from cuda.pathfinder._dynamic_libs.load_dl_common import (
+    DynamicLibNotAvailableError as DynamicLibNotAvailableError,
+)
+from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError as DynamicLibNotFoundError
+from cuda.pathfinder._dynamic_libs.load_dl_common import (
+    DynamicLibUnknownError as DynamicLibUnknownError,
+)
+from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL as LoadedDL
+from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import load_nvidia_dynamic_lib as load_nvidia_dynamic_lib
+from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import (
+    SUPPORTED_LIBNAMES as SUPPORTED_NVIDIA_LIBNAMES,  # noqa: F401
+)
+from cuda.pathfinder._headers.find_nvidia_headers import LocatedHeaderDir as LocatedHeaderDir
+from cuda.pathfinder._headers.find_nvidia_headers import find_nvidia_header_directory as find_nvidia_header_directory
+from cuda.pathfinder._headers.find_nvidia_headers import (
+    locate_nvidia_header_directory as locate_nvidia_header_directory,
+)
+from cuda.pathfinder._headers.supported_nvidia_headers import SUPPORTED_HEADERS_CTK as _SUPPORTED_HEADERS_CTK
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    SUPPORTED_BITCODE_LIBS as _SUPPORTED_BITCODE_LIBS,
+)
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    BitcodeLibNotFoundError as BitcodeLibNotFoundError,
+)
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    LocatedBitcodeLib as LocatedBitcodeLib,
+)
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    find_bitcode_lib as find_bitcode_lib,
+)
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    locate_bitcode_lib as locate_bitcode_lib,
+)
+
+from cuda.pathfinder._version import __version__  # isort: skip  # noqa: F401
+
+# Indirections to help Sphinx find the docstrings.
+#: Mapping from short CUDA Toolkit (CTK) library names to their canonical
+#: header basenames (used to validate a discovered include directory).
+#: Example: ``"cublas" → "cublas.h"``. The key set is platform-aware
+#: (e.g., ``"cufile"`` may be Linux-only).
+SUPPORTED_HEADERS_CTK = _SUPPORTED_HEADERS_CTK
+
+#: Tuple of supported CUDA binary utility names that can be located
+#: via ``find_nvidia_binary_utility()``. Platform-aware (e.g., some
+#: utilities may be available only on Linux or Windows).
+#: Example utilities: ``"nvdisasm"``, ``"cuobjdump"``, ``"nvcc"``.
+SUPPORTED_BINARY_UTILITIES = _SUPPORTED_BINARIES
+
+#: Tuple of supported bitcode library names that can be resolved
+#: via ``locate_bitcode_lib()`` and ``find_bitcode_lib()``.
+#: Example value: ``"device"``.
+SUPPORTED_BITCODE_LIBS = _SUPPORTED_BITCODE_LIBS
+
+# Backward compatibility: _find_nvidia_header_directory was added in release 1.2.2.
+# It will be removed in release 1.2.4.
+_find_nvidia_header_directory = find_nvidia_header_directory

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/cuda/pathfinder/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '1.4.0'
+__version_tuple__ = version_tuple = (1, 4, 0)
+
+__commit_id__ = commit_id = 'g8d0ccdd64'

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pip/_internal/__init__.py

@@ -0,0 +1,18 @@
+from typing import List, Optional
+
+from pip._internal.utils import _log
+
+# init_logging() must be called before any call to logging.getLogger()
+# which happens at import of most modules.
+_log.init_logging()
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """This is preserved for old console scripts that may still be referencing
+    it.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)