diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index b6d3ce549..812a14117 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -35,7 +35,7 @@ jobs: - "3.9" cuda-version: # Note: this is for build-time only. - - "12.8.0" + - "12.9.0" name: Build (${{ matrix.host-platform }}, Python ${{ matrix.python-version }}, CUDA ${{ matrix.cuda-version }}) if: ${{ github.repository_owner == 'nvidia' }} permissions: @@ -224,7 +224,7 @@ jobs: - "3.9" cuda-version: # Note: this is for test-time only. - - "12.8.0" + - "12.9.0" - "12.0.1" - "11.8.0" local-ctk: @@ -239,7 +239,7 @@ jobs: include: - host-platform: linux-64 python-version: "3.12" - cuda-version: "12.8.0" + cuda-version: "12.9.0" local-ctk: 1 runner: H100 name: Test (${{ matrix.host-platform }}, Python ${{ matrix.python-version }}, CUDA ${{ matrix.cuda-version }}, Runner ${{ matrix.runner }}, ${{ (matrix.local-ctk == '1' && 'local CTK') || 'CTK wheels' }}) @@ -270,7 +270,7 @@ jobs: - "3.12" cuda-version: # Note: this is for test-time only. - - "12.8.0" + - "12.9.0" - "11.8.0" local-ctk: - 1 # use mini CTK diff --git a/.gitignore b/.gitignore index bd3d4eb64..de32950bc 100644 --- a/.gitignore +++ b/.gitignore @@ -13,11 +13,13 @@ __pycache__/ *.cpp !cuda_bindings/cuda/bindings/_lib/param_packer.cpp !cuda_bindings/cuda/bindings/_bindings/loader.cpp +cache_driver +cache_runtime +cache_nvrtc # CUDA Python specific (auto-generated) cuda_bindings/cuda/bindings/_bindings/cydriver.pxd cuda_bindings/cuda/bindings/_bindings/cydriver.pyx -cuda_bindings/cuda/bindings/_bindings/cyruntime.pxi cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd @@ -25,6 +27,7 @@ cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx cuda_bindings/cuda/bindings/_bindings/cynvrtc.pxd cuda_bindings/cuda/bindings/_bindings/cynvrtc.pyx cuda_bindings/cuda/bindings/_internal/nvjitlink.pyx +cuda_bindings/cuda/bindings/_internal/nvvm.pyx cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pxd cuda_bindings/cuda/bindings/_lib/cyruntime/cyruntime.pyx cuda_bindings/cuda/bindings/_lib/cyruntime/utils.pxd @@ -35,6 +38,8 @@ cuda_bindings/cuda/bindings/cydriver.pxd cuda_bindings/cuda/bindings/cydriver.pyx cuda_bindings/cuda/bindings/cyruntime.pxd cuda_bindings/cuda/bindings/cyruntime.pyx +cuda_bindings/cuda/bindings/cyruntime_functions.pxi +cuda_bindings/cuda/bindings/cyruntime_types.pxi cuda_bindings/cuda/bindings/cynvrtc.pxd cuda_bindings/cuda/bindings/cynvrtc.pyx cuda_bindings/cuda/bindings/driver.pxd diff --git a/cuda_bindings/MANIFEST.in b/cuda_bindings/MANIFEST.in index b0a806442..9527072c8 100644 --- a/cuda_bindings/MANIFEST.in +++ b/cuda_bindings/MANIFEST.in @@ -1,4 +1,4 @@ -recursive-include cuda/ *.pyx *.pxd +recursive-include cuda/ *.pyx *.pxd *.pxi # at least with setuptools 75.0.0 this folder was added erroneously # to the payload, causing file copying to the build environment failed exclude cuda/bindings cuda?bindings diff --git a/cuda_bindings/cuda/bindings/_bindings/cydriver.pxd.in b/cuda_bindings/cuda/bindings/_bindings/cydriver.pxd.in index ea78183cf..2179a10bd 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cydriver.pxd.in +++ b/cuda_bindings/cuda/bindings/_bindings/cydriver.pxd.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. from cuda.bindings.cydriver cimport * {{if 'cuGetErrorString' in found_functions}} @@ -2214,6 +2214,31 @@ cdef CUresult _cuStreamGetGreenCtx(CUstream hStream, CUgreenCtx* phCtx) except ? cdef CUresult _cuGreenCtxStreamCreate(CUstream* phStream, CUgreenCtx greenCtx, unsigned int flags, int priority) except ?CUDA_ERROR_NOT_FOUND nogil {{endif}} +{{if 'cuLogsRegisterCallback' in found_functions}} + +cdef CUresult _cuLogsRegisterCallback(CUlogsCallback callbackFunc, void* userData, CUlogsCallbackHandle* callback_out) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + +{{if 'cuLogsUnregisterCallback' in found_functions}} + +cdef CUresult _cuLogsUnregisterCallback(CUlogsCallbackHandle callback) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + +{{if 'cuLogsCurrent' in found_functions}} + +cdef CUresult _cuLogsCurrent(CUlogIterator* iterator_out, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + +{{if 'cuLogsDumpToFile' in found_functions}} + +cdef CUresult _cuLogsDumpToFile(CUlogIterator* iterator, const char* pathToFile, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + +{{if 'cuLogsDumpToMemory' in found_functions}} + +cdef CUresult _cuLogsDumpToMemory(CUlogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} cdef CUresult _cuCheckpointProcessGetRestoreThreadId(int pid, int* tid) except ?CUDA_ERROR_NOT_FOUND nogil diff --git a/cuda_bindings/cuda/bindings/_bindings/cydriver.pyx.in b/cuda_bindings/cuda/bindings/_bindings/cydriver.pyx.in index 4b9528e19..44233c5b4 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cydriver.pyx.in +++ b/cuda_bindings/cuda/bindings/_bindings/cydriver.pyx.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. {{if 'Windows' == platform.system()}} import os import site @@ -16,6 +16,8 @@ from pywintypes import error {{else}} cimport cuda.bindings._lib.dlfcn as dlfcn {{endif}} + +from libc.stdint cimport intptr_t import os import sys cimport cuda.bindings._bindings.loader as loader @@ -461,6 +463,11 @@ cdef bint __cuPythonInit = False {{if 'cuGreenCtxWaitEvent' in found_functions}}cdef void *__cuGreenCtxWaitEvent = NULL{{endif}} {{if 'cuStreamGetGreenCtx' in found_functions}}cdef void *__cuStreamGetGreenCtx = NULL{{endif}} {{if 'cuGreenCtxStreamCreate' in found_functions}}cdef void *__cuGreenCtxStreamCreate = NULL{{endif}} +{{if 'cuLogsRegisterCallback' in found_functions}}cdef void *__cuLogsRegisterCallback = NULL{{endif}} +{{if 'cuLogsUnregisterCallback' in found_functions}}cdef void *__cuLogsUnregisterCallback = NULL{{endif}} +{{if 'cuLogsCurrent' in found_functions}}cdef void *__cuLogsCurrent = NULL{{endif}} +{{if 'cuLogsDumpToFile' in found_functions}}cdef void *__cuLogsDumpToFile = NULL{{endif}} +{{if 'cuLogsDumpToMemory' in found_functions}}cdef void *__cuLogsDumpToMemory = NULL{{endif}} {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}}cdef void *__cuCheckpointProcessGetRestoreThreadId = NULL{{endif}} {{if 'cuCheckpointProcessGetState' in found_functions}}cdef void *__cuCheckpointProcessGetState = NULL{{endif}} {{if 'cuCheckpointProcessLock' in found_functions}}cdef void *__cuCheckpointProcessLock = NULL{{endif}} @@ -2650,6 +2657,26 @@ cdef int cuPythonInit() except -1 nogil: global __cuGreenCtxStreamCreate cuGetProcAddress('cuGreenCtxStreamCreate', &__cuGreenCtxStreamCreate, 12050, CU_GET_PROC_ADDRESS_DEFAULT, NULL) {{endif}} + {{if 'cuLogsRegisterCallback' in found_functions}} + global __cuLogsRegisterCallback + cuGetProcAddress('cuLogsRegisterCallback', &__cuLogsRegisterCallback, 12080, CU_GET_PROC_ADDRESS_DEFAULT, NULL) + {{endif}} + {{if 'cuLogsUnregisterCallback' in found_functions}} + global __cuLogsUnregisterCallback + cuGetProcAddress('cuLogsUnregisterCallback', &__cuLogsUnregisterCallback, 12080, CU_GET_PROC_ADDRESS_DEFAULT, NULL) + {{endif}} + {{if 'cuLogsCurrent' in found_functions}} + global __cuLogsCurrent + cuGetProcAddress('cuLogsCurrent', &__cuLogsCurrent, 12080, CU_GET_PROC_ADDRESS_DEFAULT, NULL) + {{endif}} + {{if 'cuLogsDumpToFile' in found_functions}} + global __cuLogsDumpToFile + cuGetProcAddress('cuLogsDumpToFile', &__cuLogsDumpToFile, 12080, CU_GET_PROC_ADDRESS_DEFAULT, NULL) + {{endif}} + {{if 'cuLogsDumpToMemory' in found_functions}} + global __cuLogsDumpToMemory + cuGetProcAddress('cuLogsDumpToMemory', &__cuLogsDumpToMemory, 12080, CU_GET_PROC_ADDRESS_DEFAULT, NULL) + {{endif}} {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} global __cuCheckpointProcessGetRestoreThreadId cuGetProcAddress('cuCheckpointProcessGetRestoreThreadId', &__cuCheckpointProcessGetRestoreThreadId, 12080, CU_GET_PROC_ADDRESS_DEFAULT, NULL) @@ -6452,6 +6479,41 @@ cdef int cuPythonInit() except -1 nogil: except: pass {{endif}} + {{if 'cuLogsRegisterCallback' in found_functions}} + try: + global __cuLogsRegisterCallback + __cuLogsRegisterCallback = win32api.GetProcAddress(handle, 'cuLogsRegisterCallback') + except: + pass + {{endif}} + {{if 'cuLogsUnregisterCallback' in found_functions}} + try: + global __cuLogsUnregisterCallback + __cuLogsUnregisterCallback = win32api.GetProcAddress(handle, 'cuLogsUnregisterCallback') + except: + pass + {{endif}} + {{if 'cuLogsCurrent' in found_functions}} + try: + global __cuLogsCurrent + __cuLogsCurrent = win32api.GetProcAddress(handle, 'cuLogsCurrent') + except: + pass + {{endif}} + {{if 'cuLogsDumpToFile' in found_functions}} + try: + global __cuLogsDumpToFile + __cuLogsDumpToFile = win32api.GetProcAddress(handle, 'cuLogsDumpToFile') + except: + pass + {{endif}} + {{if 'cuLogsDumpToMemory' in found_functions}} + try: + global __cuLogsDumpToMemory + __cuLogsDumpToMemory = win32api.GetProcAddress(handle, 'cuLogsDumpToMemory') + except: + pass + {{endif}} {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} try: global __cuCheckpointProcessGetRestoreThreadId @@ -8754,6 +8816,26 @@ cdef int cuPythonInit() except -1 nogil: global __cuGreenCtxStreamCreate __cuGreenCtxStreamCreate = dlfcn.dlsym(handle, 'cuGreenCtxStreamCreate') {{endif}} + {{if 'cuLogsRegisterCallback' in found_functions}} + global __cuLogsRegisterCallback + __cuLogsRegisterCallback = dlfcn.dlsym(handle, 'cuLogsRegisterCallback') + {{endif}} + {{if 'cuLogsUnregisterCallback' in found_functions}} + global __cuLogsUnregisterCallback + __cuLogsUnregisterCallback = dlfcn.dlsym(handle, 'cuLogsUnregisterCallback') + {{endif}} + {{if 'cuLogsCurrent' in found_functions}} + global __cuLogsCurrent + __cuLogsCurrent = dlfcn.dlsym(handle, 'cuLogsCurrent') + {{endif}} + {{if 'cuLogsDumpToFile' in found_functions}} + global __cuLogsDumpToFile + __cuLogsDumpToFile = dlfcn.dlsym(handle, 'cuLogsDumpToFile') + {{endif}} + {{if 'cuLogsDumpToMemory' in found_functions}} + global __cuLogsDumpToMemory + __cuLogsDumpToMemory = dlfcn.dlsym(handle, 'cuLogsDumpToMemory') + {{endif}} {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} global __cuCheckpointProcessGetRestoreThreadId __cuCheckpointProcessGetRestoreThreadId = dlfcn.dlsym(handle, 'cuCheckpointProcessGetRestoreThreadId') @@ -14156,6 +14238,66 @@ cdef CUresult _cuGreenCtxStreamCreate(CUstream* phStream, CUgreenCtx greenCtx, u return err {{endif}} +{{if 'cuLogsRegisterCallback' in found_functions}} + +cdef CUresult _cuLogsRegisterCallback(CUlogsCallback callbackFunc, void* userData, CUlogsCallbackHandle* callback_out) except ?CUDA_ERROR_NOT_FOUND nogil: + global __cuLogsRegisterCallback + cuPythonInit() + if __cuLogsRegisterCallback == NULL: + with gil: + raise RuntimeError('Function "cuLogsRegisterCallback" not found') + err = ( __cuLogsRegisterCallback)(callbackFunc, userData, callback_out) + return err +{{endif}} + +{{if 'cuLogsUnregisterCallback' in found_functions}} + +cdef CUresult _cuLogsUnregisterCallback(CUlogsCallbackHandle callback) except ?CUDA_ERROR_NOT_FOUND nogil: + global __cuLogsUnregisterCallback + cuPythonInit() + if __cuLogsUnregisterCallback == NULL: + with gil: + raise RuntimeError('Function "cuLogsUnregisterCallback" not found') + err = ( __cuLogsUnregisterCallback)(callback) + return err +{{endif}} + +{{if 'cuLogsCurrent' in found_functions}} + +cdef CUresult _cuLogsCurrent(CUlogIterator* iterator_out, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: + global __cuLogsCurrent + cuPythonInit() + if __cuLogsCurrent == NULL: + with gil: + raise RuntimeError('Function "cuLogsCurrent" not found') + err = ( __cuLogsCurrent)(iterator_out, flags) + return err +{{endif}} + +{{if 'cuLogsDumpToFile' in found_functions}} + +cdef CUresult _cuLogsDumpToFile(CUlogIterator* iterator, const char* pathToFile, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: + global __cuLogsDumpToFile + cuPythonInit() + if __cuLogsDumpToFile == NULL: + with gil: + raise RuntimeError('Function "cuLogsDumpToFile" not found') + err = ( __cuLogsDumpToFile)(iterator, pathToFile, flags) + return err +{{endif}} + +{{if 'cuLogsDumpToMemory' in found_functions}} + +cdef CUresult _cuLogsDumpToMemory(CUlogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: + global __cuLogsDumpToMemory + cuPythonInit() + if __cuLogsDumpToMemory == NULL: + with gil: + raise RuntimeError('Function "cuLogsDumpToMemory" not found') + err = ( __cuLogsDumpToMemory)(iterator, buffer, size, flags) + return err +{{endif}} + {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} cdef CUresult _cuCheckpointProcessGetRestoreThreadId(int pid, int* tid) except ?CUDA_ERROR_NOT_FOUND nogil: @@ -14479,3 +14621,3333 @@ cdef CUresult _cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaRes err = ( __cuGraphicsVDPAURegisterOutputSurface)(pCudaResource, vdpSurface, flags) return err {{endif}} + +cdef dict func_ptrs = None + +cpdef dict _inspect_function_pointers(): + global func_ptrs + if func_ptrs is not None: + return func_ptrs + + cuPythonInit() + cdef dict data = {} + + {{if 'cuGetErrorString' in found_functions}} + global __cuGetErrorString + data["__cuGetErrorString"] = __cuGetErrorString + {{else}} + data["__cuGetErrorString"] = 0 + {{endif}} + + {{if 'cuGetErrorName' in found_functions}} + global __cuGetErrorName + data["__cuGetErrorName"] = __cuGetErrorName + {{else}} + data["__cuGetErrorName"] = 0 + {{endif}} + + {{if 'cuInit' in found_functions}} + global __cuInit + data["__cuInit"] = __cuInit + {{else}} + data["__cuInit"] = 0 + {{endif}} + + {{if 'cuDriverGetVersion' in found_functions}} + global __cuDriverGetVersion + data["__cuDriverGetVersion"] = __cuDriverGetVersion + {{else}} + data["__cuDriverGetVersion"] = 0 + {{endif}} + + {{if 'cuDeviceGet' in found_functions}} + global __cuDeviceGet + data["__cuDeviceGet"] = __cuDeviceGet + {{else}} + data["__cuDeviceGet"] = 0 + {{endif}} + + {{if 'cuDeviceGetCount' in found_functions}} + global __cuDeviceGetCount + data["__cuDeviceGetCount"] = __cuDeviceGetCount + {{else}} + data["__cuDeviceGetCount"] = 0 + {{endif}} + + {{if 'cuDeviceGetName' in found_functions}} + global __cuDeviceGetName + data["__cuDeviceGetName"] = __cuDeviceGetName + {{else}} + data["__cuDeviceGetName"] = 0 + {{endif}} + + {{if 'cuDeviceGetUuid' in found_functions}} + global __cuDeviceGetUuid + data["__cuDeviceGetUuid"] = __cuDeviceGetUuid + {{else}} + data["__cuDeviceGetUuid"] = 0 + {{endif}} + + {{if 'cuDeviceGetUuid_v2' in found_functions}} + global __cuDeviceGetUuid_v2 + data["__cuDeviceGetUuid_v2"] = __cuDeviceGetUuid_v2 + {{else}} + data["__cuDeviceGetUuid_v2"] = 0 + {{endif}} + + {{if 'cuDeviceGetLuid' in found_functions}} + global __cuDeviceGetLuid + data["__cuDeviceGetLuid"] = __cuDeviceGetLuid + {{else}} + data["__cuDeviceGetLuid"] = 0 + {{endif}} + + {{if 'cuDeviceTotalMem_v2' in found_functions}} + global __cuDeviceTotalMem_v2 + data["__cuDeviceTotalMem_v2"] = __cuDeviceTotalMem_v2 + {{else}} + data["__cuDeviceTotalMem_v2"] = 0 + {{endif}} + + {{if 'cuDeviceGetTexture1DLinearMaxWidth' in found_functions}} + global __cuDeviceGetTexture1DLinearMaxWidth + data["__cuDeviceGetTexture1DLinearMaxWidth"] = __cuDeviceGetTexture1DLinearMaxWidth + {{else}} + data["__cuDeviceGetTexture1DLinearMaxWidth"] = 0 + {{endif}} + + {{if 'cuDeviceGetAttribute' in found_functions}} + global __cuDeviceGetAttribute + data["__cuDeviceGetAttribute"] = __cuDeviceGetAttribute + {{else}} + data["__cuDeviceGetAttribute"] = 0 + {{endif}} + + {{if 'cuDeviceGetNvSciSyncAttributes' in found_functions}} + global __cuDeviceGetNvSciSyncAttributes + data["__cuDeviceGetNvSciSyncAttributes"] = __cuDeviceGetNvSciSyncAttributes + {{else}} + data["__cuDeviceGetNvSciSyncAttributes"] = 0 + {{endif}} + + {{if 'cuDeviceSetMemPool' in found_functions}} + global __cuDeviceSetMemPool + data["__cuDeviceSetMemPool"] = __cuDeviceSetMemPool + {{else}} + data["__cuDeviceSetMemPool"] = 0 + {{endif}} + + {{if 'cuDeviceGetMemPool' in found_functions}} + global __cuDeviceGetMemPool + data["__cuDeviceGetMemPool"] = __cuDeviceGetMemPool + {{else}} + data["__cuDeviceGetMemPool"] = 0 + {{endif}} + + {{if 'cuDeviceGetDefaultMemPool' in found_functions}} + global __cuDeviceGetDefaultMemPool + data["__cuDeviceGetDefaultMemPool"] = __cuDeviceGetDefaultMemPool + {{else}} + data["__cuDeviceGetDefaultMemPool"] = 0 + {{endif}} + + {{if 'cuDeviceGetExecAffinitySupport' in found_functions}} + global __cuDeviceGetExecAffinitySupport + data["__cuDeviceGetExecAffinitySupport"] = __cuDeviceGetExecAffinitySupport + {{else}} + data["__cuDeviceGetExecAffinitySupport"] = 0 + {{endif}} + + {{if 'cuFlushGPUDirectRDMAWrites' in found_functions}} + global __cuFlushGPUDirectRDMAWrites + data["__cuFlushGPUDirectRDMAWrites"] = __cuFlushGPUDirectRDMAWrites + {{else}} + data["__cuFlushGPUDirectRDMAWrites"] = 0 + {{endif}} + + {{if 'cuDeviceGetProperties' in found_functions}} + global __cuDeviceGetProperties + data["__cuDeviceGetProperties"] = __cuDeviceGetProperties + {{else}} + data["__cuDeviceGetProperties"] = 0 + {{endif}} + + {{if 'cuDeviceComputeCapability' in found_functions}} + global __cuDeviceComputeCapability + data["__cuDeviceComputeCapability"] = __cuDeviceComputeCapability + {{else}} + data["__cuDeviceComputeCapability"] = 0 + {{endif}} + + {{if 'cuDevicePrimaryCtxRetain' in found_functions}} + global __cuDevicePrimaryCtxRetain + data["__cuDevicePrimaryCtxRetain"] = __cuDevicePrimaryCtxRetain + {{else}} + data["__cuDevicePrimaryCtxRetain"] = 0 + {{endif}} + + {{if 'cuDevicePrimaryCtxRelease_v2' in found_functions}} + global __cuDevicePrimaryCtxRelease_v2 + data["__cuDevicePrimaryCtxRelease_v2"] = __cuDevicePrimaryCtxRelease_v2 + {{else}} + data["__cuDevicePrimaryCtxRelease_v2"] = 0 + {{endif}} + + {{if 'cuDevicePrimaryCtxSetFlags_v2' in found_functions}} + global __cuDevicePrimaryCtxSetFlags_v2 + data["__cuDevicePrimaryCtxSetFlags_v2"] = __cuDevicePrimaryCtxSetFlags_v2 + {{else}} + data["__cuDevicePrimaryCtxSetFlags_v2"] = 0 + {{endif}} + + {{if 'cuDevicePrimaryCtxGetState' in found_functions}} + global __cuDevicePrimaryCtxGetState + data["__cuDevicePrimaryCtxGetState"] = __cuDevicePrimaryCtxGetState + {{else}} + data["__cuDevicePrimaryCtxGetState"] = 0 + {{endif}} + + {{if 'cuDevicePrimaryCtxReset_v2' in found_functions}} + global __cuDevicePrimaryCtxReset_v2 + data["__cuDevicePrimaryCtxReset_v2"] = __cuDevicePrimaryCtxReset_v2 + {{else}} + data["__cuDevicePrimaryCtxReset_v2"] = 0 + {{endif}} + + {{if 'cuCtxCreate_v2' in found_functions}} + global __cuCtxCreate_v2 + data["__cuCtxCreate_v2"] = __cuCtxCreate_v2 + {{else}} + data["__cuCtxCreate_v2"] = 0 + {{endif}} + + {{if 'cuCtxCreate_v3' in found_functions}} + global __cuCtxCreate_v3 + data["__cuCtxCreate_v3"] = __cuCtxCreate_v3 + {{else}} + data["__cuCtxCreate_v3"] = 0 + {{endif}} + + {{if 'cuCtxCreate_v4' in found_functions}} + global __cuCtxCreate_v4 + data["__cuCtxCreate_v4"] = __cuCtxCreate_v4 + {{else}} + data["__cuCtxCreate_v4"] = 0 + {{endif}} + + {{if 'cuCtxDestroy_v2' in found_functions}} + global __cuCtxDestroy_v2 + data["__cuCtxDestroy_v2"] = __cuCtxDestroy_v2 + {{else}} + data["__cuCtxDestroy_v2"] = 0 + {{endif}} + + {{if 'cuCtxPushCurrent_v2' in found_functions}} + global __cuCtxPushCurrent_v2 + data["__cuCtxPushCurrent_v2"] = __cuCtxPushCurrent_v2 + {{else}} + data["__cuCtxPushCurrent_v2"] = 0 + {{endif}} + + {{if 'cuCtxPopCurrent_v2' in found_functions}} + global __cuCtxPopCurrent_v2 + data["__cuCtxPopCurrent_v2"] = __cuCtxPopCurrent_v2 + {{else}} + data["__cuCtxPopCurrent_v2"] = 0 + {{endif}} + + {{if 'cuCtxSetCurrent' in found_functions}} + global __cuCtxSetCurrent + data["__cuCtxSetCurrent"] = __cuCtxSetCurrent + {{else}} + data["__cuCtxSetCurrent"] = 0 + {{endif}} + + {{if 'cuCtxGetCurrent' in found_functions}} + global __cuCtxGetCurrent + data["__cuCtxGetCurrent"] = __cuCtxGetCurrent + {{else}} + data["__cuCtxGetCurrent"] = 0 + {{endif}} + + {{if 'cuCtxGetDevice' in found_functions}} + global __cuCtxGetDevice + data["__cuCtxGetDevice"] = __cuCtxGetDevice + {{else}} + data["__cuCtxGetDevice"] = 0 + {{endif}} + + {{if 'cuCtxGetFlags' in found_functions}} + global __cuCtxGetFlags + data["__cuCtxGetFlags"] = __cuCtxGetFlags + {{else}} + data["__cuCtxGetFlags"] = 0 + {{endif}} + + {{if 'cuCtxSetFlags' in found_functions}} + global __cuCtxSetFlags + data["__cuCtxSetFlags"] = __cuCtxSetFlags + {{else}} + data["__cuCtxSetFlags"] = 0 + {{endif}} + + {{if 'cuCtxGetId' in found_functions}} + global __cuCtxGetId + data["__cuCtxGetId"] = __cuCtxGetId + {{else}} + data["__cuCtxGetId"] = 0 + {{endif}} + + {{if 'cuCtxSynchronize' in found_functions}} + global __cuCtxSynchronize + data["__cuCtxSynchronize"] = __cuCtxSynchronize + {{else}} + data["__cuCtxSynchronize"] = 0 + {{endif}} + + {{if 'cuCtxSetLimit' in found_functions}} + global __cuCtxSetLimit + data["__cuCtxSetLimit"] = __cuCtxSetLimit + {{else}} + data["__cuCtxSetLimit"] = 0 + {{endif}} + + {{if 'cuCtxGetLimit' in found_functions}} + global __cuCtxGetLimit + data["__cuCtxGetLimit"] = __cuCtxGetLimit + {{else}} + data["__cuCtxGetLimit"] = 0 + {{endif}} + + {{if 'cuCtxGetCacheConfig' in found_functions}} + global __cuCtxGetCacheConfig + data["__cuCtxGetCacheConfig"] = __cuCtxGetCacheConfig + {{else}} + data["__cuCtxGetCacheConfig"] = 0 + {{endif}} + + {{if 'cuCtxSetCacheConfig' in found_functions}} + global __cuCtxSetCacheConfig + data["__cuCtxSetCacheConfig"] = __cuCtxSetCacheConfig + {{else}} + data["__cuCtxSetCacheConfig"] = 0 + {{endif}} + + {{if 'cuCtxGetApiVersion' in found_functions}} + global __cuCtxGetApiVersion + data["__cuCtxGetApiVersion"] = __cuCtxGetApiVersion + {{else}} + data["__cuCtxGetApiVersion"] = 0 + {{endif}} + + {{if 'cuCtxGetStreamPriorityRange' in found_functions}} + global __cuCtxGetStreamPriorityRange + data["__cuCtxGetStreamPriorityRange"] = __cuCtxGetStreamPriorityRange + {{else}} + data["__cuCtxGetStreamPriorityRange"] = 0 + {{endif}} + + {{if 'cuCtxResetPersistingL2Cache' in found_functions}} + global __cuCtxResetPersistingL2Cache + data["__cuCtxResetPersistingL2Cache"] = __cuCtxResetPersistingL2Cache + {{else}} + data["__cuCtxResetPersistingL2Cache"] = 0 + {{endif}} + + {{if 'cuCtxGetExecAffinity' in found_functions}} + global __cuCtxGetExecAffinity + data["__cuCtxGetExecAffinity"] = __cuCtxGetExecAffinity + {{else}} + data["__cuCtxGetExecAffinity"] = 0 + {{endif}} + + {{if 'cuCtxRecordEvent' in found_functions}} + global __cuCtxRecordEvent + data["__cuCtxRecordEvent"] = __cuCtxRecordEvent + {{else}} + data["__cuCtxRecordEvent"] = 0 + {{endif}} + + {{if 'cuCtxWaitEvent' in found_functions}} + global __cuCtxWaitEvent + data["__cuCtxWaitEvent"] = __cuCtxWaitEvent + {{else}} + data["__cuCtxWaitEvent"] = 0 + {{endif}} + + {{if 'cuCtxAttach' in found_functions}} + global __cuCtxAttach + data["__cuCtxAttach"] = __cuCtxAttach + {{else}} + data["__cuCtxAttach"] = 0 + {{endif}} + + {{if 'cuCtxDetach' in found_functions}} + global __cuCtxDetach + data["__cuCtxDetach"] = __cuCtxDetach + {{else}} + data["__cuCtxDetach"] = 0 + {{endif}} + + {{if 'cuCtxGetSharedMemConfig' in found_functions}} + global __cuCtxGetSharedMemConfig + data["__cuCtxGetSharedMemConfig"] = __cuCtxGetSharedMemConfig + {{else}} + data["__cuCtxGetSharedMemConfig"] = 0 + {{endif}} + + {{if 'cuCtxSetSharedMemConfig' in found_functions}} + global __cuCtxSetSharedMemConfig + data["__cuCtxSetSharedMemConfig"] = __cuCtxSetSharedMemConfig + {{else}} + data["__cuCtxSetSharedMemConfig"] = 0 + {{endif}} + + {{if 'cuModuleLoad' in found_functions}} + global __cuModuleLoad + data["__cuModuleLoad"] = __cuModuleLoad + {{else}} + data["__cuModuleLoad"] = 0 + {{endif}} + + {{if 'cuModuleLoadData' in found_functions}} + global __cuModuleLoadData + data["__cuModuleLoadData"] = __cuModuleLoadData + {{else}} + data["__cuModuleLoadData"] = 0 + {{endif}} + + {{if 'cuModuleLoadDataEx' in found_functions}} + global __cuModuleLoadDataEx + data["__cuModuleLoadDataEx"] = __cuModuleLoadDataEx + {{else}} + data["__cuModuleLoadDataEx"] = 0 + {{endif}} + + {{if 'cuModuleLoadFatBinary' in found_functions}} + global __cuModuleLoadFatBinary + data["__cuModuleLoadFatBinary"] = __cuModuleLoadFatBinary + {{else}} + data["__cuModuleLoadFatBinary"] = 0 + {{endif}} + + {{if 'cuModuleUnload' in found_functions}} + global __cuModuleUnload + data["__cuModuleUnload"] = __cuModuleUnload + {{else}} + data["__cuModuleUnload"] = 0 + {{endif}} + + {{if 'cuModuleGetLoadingMode' in found_functions}} + global __cuModuleGetLoadingMode + data["__cuModuleGetLoadingMode"] = __cuModuleGetLoadingMode + {{else}} + data["__cuModuleGetLoadingMode"] = 0 + {{endif}} + + {{if 'cuModuleGetFunction' in found_functions}} + global __cuModuleGetFunction + data["__cuModuleGetFunction"] = __cuModuleGetFunction + {{else}} + data["__cuModuleGetFunction"] = 0 + {{endif}} + + {{if 'cuModuleGetFunctionCount' in found_functions}} + global __cuModuleGetFunctionCount + data["__cuModuleGetFunctionCount"] = __cuModuleGetFunctionCount + {{else}} + data["__cuModuleGetFunctionCount"] = 0 + {{endif}} + + {{if 'cuModuleEnumerateFunctions' in found_functions}} + global __cuModuleEnumerateFunctions + data["__cuModuleEnumerateFunctions"] = __cuModuleEnumerateFunctions + {{else}} + data["__cuModuleEnumerateFunctions"] = 0 + {{endif}} + + {{if 'cuModuleGetGlobal_v2' in found_functions}} + global __cuModuleGetGlobal_v2 + data["__cuModuleGetGlobal_v2"] = __cuModuleGetGlobal_v2 + {{else}} + data["__cuModuleGetGlobal_v2"] = 0 + {{endif}} + + {{if 'cuLinkCreate_v2' in found_functions}} + global __cuLinkCreate_v2 + data["__cuLinkCreate_v2"] = __cuLinkCreate_v2 + {{else}} + data["__cuLinkCreate_v2"] = 0 + {{endif}} + + {{if 'cuLinkAddData_v2' in found_functions}} + global __cuLinkAddData_v2 + data["__cuLinkAddData_v2"] = __cuLinkAddData_v2 + {{else}} + data["__cuLinkAddData_v2"] = 0 + {{endif}} + + {{if 'cuLinkAddFile_v2' in found_functions}} + global __cuLinkAddFile_v2 + data["__cuLinkAddFile_v2"] = __cuLinkAddFile_v2 + {{else}} + data["__cuLinkAddFile_v2"] = 0 + {{endif}} + + {{if 'cuLinkComplete' in found_functions}} + global __cuLinkComplete + data["__cuLinkComplete"] = __cuLinkComplete + {{else}} + data["__cuLinkComplete"] = 0 + {{endif}} + + {{if 'cuLinkDestroy' in found_functions}} + global __cuLinkDestroy + data["__cuLinkDestroy"] = __cuLinkDestroy + {{else}} + data["__cuLinkDestroy"] = 0 + {{endif}} + + {{if 'cuModuleGetTexRef' in found_functions}} + global __cuModuleGetTexRef + data["__cuModuleGetTexRef"] = __cuModuleGetTexRef + {{else}} + data["__cuModuleGetTexRef"] = 0 + {{endif}} + + {{if 'cuModuleGetSurfRef' in found_functions}} + global __cuModuleGetSurfRef + data["__cuModuleGetSurfRef"] = __cuModuleGetSurfRef + {{else}} + data["__cuModuleGetSurfRef"] = 0 + {{endif}} + + {{if 'cuLibraryLoadData' in found_functions}} + global __cuLibraryLoadData + data["__cuLibraryLoadData"] = __cuLibraryLoadData + {{else}} + data["__cuLibraryLoadData"] = 0 + {{endif}} + + {{if 'cuLibraryLoadFromFile' in found_functions}} + global __cuLibraryLoadFromFile + data["__cuLibraryLoadFromFile"] = __cuLibraryLoadFromFile + {{else}} + data["__cuLibraryLoadFromFile"] = 0 + {{endif}} + + {{if 'cuLibraryUnload' in found_functions}} + global __cuLibraryUnload + data["__cuLibraryUnload"] = __cuLibraryUnload + {{else}} + data["__cuLibraryUnload"] = 0 + {{endif}} + + {{if 'cuLibraryGetKernel' in found_functions}} + global __cuLibraryGetKernel + data["__cuLibraryGetKernel"] = __cuLibraryGetKernel + {{else}} + data["__cuLibraryGetKernel"] = 0 + {{endif}} + + {{if 'cuLibraryGetKernelCount' in found_functions}} + global __cuLibraryGetKernelCount + data["__cuLibraryGetKernelCount"] = __cuLibraryGetKernelCount + {{else}} + data["__cuLibraryGetKernelCount"] = 0 + {{endif}} + + {{if 'cuLibraryEnumerateKernels' in found_functions}} + global __cuLibraryEnumerateKernels + data["__cuLibraryEnumerateKernels"] = __cuLibraryEnumerateKernels + {{else}} + data["__cuLibraryEnumerateKernels"] = 0 + {{endif}} + + {{if 'cuLibraryGetModule' in found_functions}} + global __cuLibraryGetModule + data["__cuLibraryGetModule"] = __cuLibraryGetModule + {{else}} + data["__cuLibraryGetModule"] = 0 + {{endif}} + + {{if 'cuKernelGetFunction' in found_functions}} + global __cuKernelGetFunction + data["__cuKernelGetFunction"] = __cuKernelGetFunction + {{else}} + data["__cuKernelGetFunction"] = 0 + {{endif}} + + {{if 'cuKernelGetLibrary' in found_functions}} + global __cuKernelGetLibrary + data["__cuKernelGetLibrary"] = __cuKernelGetLibrary + {{else}} + data["__cuKernelGetLibrary"] = 0 + {{endif}} + + {{if 'cuLibraryGetGlobal' in found_functions}} + global __cuLibraryGetGlobal + data["__cuLibraryGetGlobal"] = __cuLibraryGetGlobal + {{else}} + data["__cuLibraryGetGlobal"] = 0 + {{endif}} + + {{if 'cuLibraryGetManaged' in found_functions}} + global __cuLibraryGetManaged + data["__cuLibraryGetManaged"] = __cuLibraryGetManaged + {{else}} + data["__cuLibraryGetManaged"] = 0 + {{endif}} + + {{if 'cuLibraryGetUnifiedFunction' in found_functions}} + global __cuLibraryGetUnifiedFunction + data["__cuLibraryGetUnifiedFunction"] = __cuLibraryGetUnifiedFunction + {{else}} + data["__cuLibraryGetUnifiedFunction"] = 0 + {{endif}} + + {{if 'cuKernelGetAttribute' in found_functions}} + global __cuKernelGetAttribute + data["__cuKernelGetAttribute"] = __cuKernelGetAttribute + {{else}} + data["__cuKernelGetAttribute"] = 0 + {{endif}} + + {{if 'cuKernelSetAttribute' in found_functions}} + global __cuKernelSetAttribute + data["__cuKernelSetAttribute"] = __cuKernelSetAttribute + {{else}} + data["__cuKernelSetAttribute"] = 0 + {{endif}} + + {{if 'cuKernelSetCacheConfig' in found_functions}} + global __cuKernelSetCacheConfig + data["__cuKernelSetCacheConfig"] = __cuKernelSetCacheConfig + {{else}} + data["__cuKernelSetCacheConfig"] = 0 + {{endif}} + + {{if 'cuKernelGetName' in found_functions}} + global __cuKernelGetName + data["__cuKernelGetName"] = __cuKernelGetName + {{else}} + data["__cuKernelGetName"] = 0 + {{endif}} + + {{if 'cuKernelGetParamInfo' in found_functions}} + global __cuKernelGetParamInfo + data["__cuKernelGetParamInfo"] = __cuKernelGetParamInfo + {{else}} + data["__cuKernelGetParamInfo"] = 0 + {{endif}} + + {{if 'cuMemGetInfo_v2' in found_functions}} + global __cuMemGetInfo_v2 + data["__cuMemGetInfo_v2"] = __cuMemGetInfo_v2 + {{else}} + data["__cuMemGetInfo_v2"] = 0 + {{endif}} + + {{if 'cuMemAlloc_v2' in found_functions}} + global __cuMemAlloc_v2 + data["__cuMemAlloc_v2"] = __cuMemAlloc_v2 + {{else}} + data["__cuMemAlloc_v2"] = 0 + {{endif}} + + {{if 'cuMemAllocPitch_v2' in found_functions}} + global __cuMemAllocPitch_v2 + data["__cuMemAllocPitch_v2"] = __cuMemAllocPitch_v2 + {{else}} + data["__cuMemAllocPitch_v2"] = 0 + {{endif}} + + {{if 'cuMemFree_v2' in found_functions}} + global __cuMemFree_v2 + data["__cuMemFree_v2"] = __cuMemFree_v2 + {{else}} + data["__cuMemFree_v2"] = 0 + {{endif}} + + {{if 'cuMemGetAddressRange_v2' in found_functions}} + global __cuMemGetAddressRange_v2 + data["__cuMemGetAddressRange_v2"] = __cuMemGetAddressRange_v2 + {{else}} + data["__cuMemGetAddressRange_v2"] = 0 + {{endif}} + + {{if 'cuMemAllocHost_v2' in found_functions}} + global __cuMemAllocHost_v2 + data["__cuMemAllocHost_v2"] = __cuMemAllocHost_v2 + {{else}} + data["__cuMemAllocHost_v2"] = 0 + {{endif}} + + {{if 'cuMemFreeHost' in found_functions}} + global __cuMemFreeHost + data["__cuMemFreeHost"] = __cuMemFreeHost + {{else}} + data["__cuMemFreeHost"] = 0 + {{endif}} + + {{if 'cuMemHostAlloc' in found_functions}} + global __cuMemHostAlloc + data["__cuMemHostAlloc"] = __cuMemHostAlloc + {{else}} + data["__cuMemHostAlloc"] = 0 + {{endif}} + + {{if 'cuMemHostGetDevicePointer_v2' in found_functions}} + global __cuMemHostGetDevicePointer_v2 + data["__cuMemHostGetDevicePointer_v2"] = __cuMemHostGetDevicePointer_v2 + {{else}} + data["__cuMemHostGetDevicePointer_v2"] = 0 + {{endif}} + + {{if 'cuMemHostGetFlags' in found_functions}} + global __cuMemHostGetFlags + data["__cuMemHostGetFlags"] = __cuMemHostGetFlags + {{else}} + data["__cuMemHostGetFlags"] = 0 + {{endif}} + + {{if 'cuMemAllocManaged' in found_functions}} + global __cuMemAllocManaged + data["__cuMemAllocManaged"] = __cuMemAllocManaged + {{else}} + data["__cuMemAllocManaged"] = 0 + {{endif}} + + {{if 'cuDeviceRegisterAsyncNotification' in found_functions}} + global __cuDeviceRegisterAsyncNotification + data["__cuDeviceRegisterAsyncNotification"] = __cuDeviceRegisterAsyncNotification + {{else}} + data["__cuDeviceRegisterAsyncNotification"] = 0 + {{endif}} + + {{if 'cuDeviceUnregisterAsyncNotification' in found_functions}} + global __cuDeviceUnregisterAsyncNotification + data["__cuDeviceUnregisterAsyncNotification"] = __cuDeviceUnregisterAsyncNotification + {{else}} + data["__cuDeviceUnregisterAsyncNotification"] = 0 + {{endif}} + + {{if 'cuDeviceGetByPCIBusId' in found_functions}} + global __cuDeviceGetByPCIBusId + data["__cuDeviceGetByPCIBusId"] = __cuDeviceGetByPCIBusId + {{else}} + data["__cuDeviceGetByPCIBusId"] = 0 + {{endif}} + + {{if 'cuDeviceGetPCIBusId' in found_functions}} + global __cuDeviceGetPCIBusId + data["__cuDeviceGetPCIBusId"] = __cuDeviceGetPCIBusId + {{else}} + data["__cuDeviceGetPCIBusId"] = 0 + {{endif}} + + {{if 'cuIpcGetEventHandle' in found_functions}} + global __cuIpcGetEventHandle + data["__cuIpcGetEventHandle"] = __cuIpcGetEventHandle + {{else}} + data["__cuIpcGetEventHandle"] = 0 + {{endif}} + + {{if 'cuIpcOpenEventHandle' in found_functions}} + global __cuIpcOpenEventHandle + data["__cuIpcOpenEventHandle"] = __cuIpcOpenEventHandle + {{else}} + data["__cuIpcOpenEventHandle"] = 0 + {{endif}} + + {{if 'cuIpcGetMemHandle' in found_functions}} + global __cuIpcGetMemHandle + data["__cuIpcGetMemHandle"] = __cuIpcGetMemHandle + {{else}} + data["__cuIpcGetMemHandle"] = 0 + {{endif}} + + {{if 'cuIpcOpenMemHandle_v2' in found_functions}} + global __cuIpcOpenMemHandle_v2 + data["__cuIpcOpenMemHandle_v2"] = __cuIpcOpenMemHandle_v2 + {{else}} + data["__cuIpcOpenMemHandle_v2"] = 0 + {{endif}} + + {{if 'cuIpcCloseMemHandle' in found_functions}} + global __cuIpcCloseMemHandle + data["__cuIpcCloseMemHandle"] = __cuIpcCloseMemHandle + {{else}} + data["__cuIpcCloseMemHandle"] = 0 + {{endif}} + + {{if 'cuMemHostRegister_v2' in found_functions}} + global __cuMemHostRegister_v2 + data["__cuMemHostRegister_v2"] = __cuMemHostRegister_v2 + {{else}} + data["__cuMemHostRegister_v2"] = 0 + {{endif}} + + {{if 'cuMemHostUnregister' in found_functions}} + global __cuMemHostUnregister + data["__cuMemHostUnregister"] = __cuMemHostUnregister + {{else}} + data["__cuMemHostUnregister"] = 0 + {{endif}} + + {{if 'cuMemcpy' in found_functions}} + global __cuMemcpy + data["__cuMemcpy"] = __cuMemcpy + {{else}} + data["__cuMemcpy"] = 0 + {{endif}} + + {{if 'cuMemcpyPeer' in found_functions}} + global __cuMemcpyPeer + data["__cuMemcpyPeer"] = __cuMemcpyPeer + {{else}} + data["__cuMemcpyPeer"] = 0 + {{endif}} + + {{if 'cuMemcpyHtoD_v2' in found_functions}} + global __cuMemcpyHtoD_v2 + data["__cuMemcpyHtoD_v2"] = __cuMemcpyHtoD_v2 + {{else}} + data["__cuMemcpyHtoD_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyDtoH_v2' in found_functions}} + global __cuMemcpyDtoH_v2 + data["__cuMemcpyDtoH_v2"] = __cuMemcpyDtoH_v2 + {{else}} + data["__cuMemcpyDtoH_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyDtoD_v2' in found_functions}} + global __cuMemcpyDtoD_v2 + data["__cuMemcpyDtoD_v2"] = __cuMemcpyDtoD_v2 + {{else}} + data["__cuMemcpyDtoD_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyDtoA_v2' in found_functions}} + global __cuMemcpyDtoA_v2 + data["__cuMemcpyDtoA_v2"] = __cuMemcpyDtoA_v2 + {{else}} + data["__cuMemcpyDtoA_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyAtoD_v2' in found_functions}} + global __cuMemcpyAtoD_v2 + data["__cuMemcpyAtoD_v2"] = __cuMemcpyAtoD_v2 + {{else}} + data["__cuMemcpyAtoD_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyHtoA_v2' in found_functions}} + global __cuMemcpyHtoA_v2 + data["__cuMemcpyHtoA_v2"] = __cuMemcpyHtoA_v2 + {{else}} + data["__cuMemcpyHtoA_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyAtoH_v2' in found_functions}} + global __cuMemcpyAtoH_v2 + data["__cuMemcpyAtoH_v2"] = __cuMemcpyAtoH_v2 + {{else}} + data["__cuMemcpyAtoH_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyAtoA_v2' in found_functions}} + global __cuMemcpyAtoA_v2 + data["__cuMemcpyAtoA_v2"] = __cuMemcpyAtoA_v2 + {{else}} + data["__cuMemcpyAtoA_v2"] = 0 + {{endif}} + + {{if 'cuMemcpy2D_v2' in found_functions}} + global __cuMemcpy2D_v2 + data["__cuMemcpy2D_v2"] = __cuMemcpy2D_v2 + {{else}} + data["__cuMemcpy2D_v2"] = 0 + {{endif}} + + {{if 'cuMemcpy2DUnaligned_v2' in found_functions}} + global __cuMemcpy2DUnaligned_v2 + data["__cuMemcpy2DUnaligned_v2"] = __cuMemcpy2DUnaligned_v2 + {{else}} + data["__cuMemcpy2DUnaligned_v2"] = 0 + {{endif}} + + {{if 'cuMemcpy3D_v2' in found_functions}} + global __cuMemcpy3D_v2 + data["__cuMemcpy3D_v2"] = __cuMemcpy3D_v2 + {{else}} + data["__cuMemcpy3D_v2"] = 0 + {{endif}} + + {{if 'cuMemcpy3DPeer' in found_functions}} + global __cuMemcpy3DPeer + data["__cuMemcpy3DPeer"] = __cuMemcpy3DPeer + {{else}} + data["__cuMemcpy3DPeer"] = 0 + {{endif}} + + {{if 'cuMemcpyAsync' in found_functions}} + global __cuMemcpyAsync + data["__cuMemcpyAsync"] = __cuMemcpyAsync + {{else}} + data["__cuMemcpyAsync"] = 0 + {{endif}} + + {{if 'cuMemcpyPeerAsync' in found_functions}} + global __cuMemcpyPeerAsync + data["__cuMemcpyPeerAsync"] = __cuMemcpyPeerAsync + {{else}} + data["__cuMemcpyPeerAsync"] = 0 + {{endif}} + + {{if 'cuMemcpyHtoDAsync_v2' in found_functions}} + global __cuMemcpyHtoDAsync_v2 + data["__cuMemcpyHtoDAsync_v2"] = __cuMemcpyHtoDAsync_v2 + {{else}} + data["__cuMemcpyHtoDAsync_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyDtoHAsync_v2' in found_functions}} + global __cuMemcpyDtoHAsync_v2 + data["__cuMemcpyDtoHAsync_v2"] = __cuMemcpyDtoHAsync_v2 + {{else}} + data["__cuMemcpyDtoHAsync_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyDtoDAsync_v2' in found_functions}} + global __cuMemcpyDtoDAsync_v2 + data["__cuMemcpyDtoDAsync_v2"] = __cuMemcpyDtoDAsync_v2 + {{else}} + data["__cuMemcpyDtoDAsync_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyHtoAAsync_v2' in found_functions}} + global __cuMemcpyHtoAAsync_v2 + data["__cuMemcpyHtoAAsync_v2"] = __cuMemcpyHtoAAsync_v2 + {{else}} + data["__cuMemcpyHtoAAsync_v2"] = 0 + {{endif}} + + {{if 'cuMemcpyAtoHAsync_v2' in found_functions}} + global __cuMemcpyAtoHAsync_v2 + data["__cuMemcpyAtoHAsync_v2"] = __cuMemcpyAtoHAsync_v2 + {{else}} + data["__cuMemcpyAtoHAsync_v2"] = 0 + {{endif}} + + {{if 'cuMemcpy2DAsync_v2' in found_functions}} + global __cuMemcpy2DAsync_v2 + data["__cuMemcpy2DAsync_v2"] = __cuMemcpy2DAsync_v2 + {{else}} + data["__cuMemcpy2DAsync_v2"] = 0 + {{endif}} + + {{if 'cuMemcpy3DAsync_v2' in found_functions}} + global __cuMemcpy3DAsync_v2 + data["__cuMemcpy3DAsync_v2"] = __cuMemcpy3DAsync_v2 + {{else}} + data["__cuMemcpy3DAsync_v2"] = 0 + {{endif}} + + {{if 'cuMemcpy3DPeerAsync' in found_functions}} + global __cuMemcpy3DPeerAsync + data["__cuMemcpy3DPeerAsync"] = __cuMemcpy3DPeerAsync + {{else}} + data["__cuMemcpy3DPeerAsync"] = 0 + {{endif}} + + {{if 'cuMemcpyBatchAsync' in found_functions}} + global __cuMemcpyBatchAsync + data["__cuMemcpyBatchAsync"] = __cuMemcpyBatchAsync + {{else}} + data["__cuMemcpyBatchAsync"] = 0 + {{endif}} + + {{if 'cuMemcpy3DBatchAsync' in found_functions}} + global __cuMemcpy3DBatchAsync + data["__cuMemcpy3DBatchAsync"] = __cuMemcpy3DBatchAsync + {{else}} + data["__cuMemcpy3DBatchAsync"] = 0 + {{endif}} + + {{if 'cuMemsetD8_v2' in found_functions}} + global __cuMemsetD8_v2 + data["__cuMemsetD8_v2"] = __cuMemsetD8_v2 + {{else}} + data["__cuMemsetD8_v2"] = 0 + {{endif}} + + {{if 'cuMemsetD16_v2' in found_functions}} + global __cuMemsetD16_v2 + data["__cuMemsetD16_v2"] = __cuMemsetD16_v2 + {{else}} + data["__cuMemsetD16_v2"] = 0 + {{endif}} + + {{if 'cuMemsetD32_v2' in found_functions}} + global __cuMemsetD32_v2 + data["__cuMemsetD32_v2"] = __cuMemsetD32_v2 + {{else}} + data["__cuMemsetD32_v2"] = 0 + {{endif}} + + {{if 'cuMemsetD2D8_v2' in found_functions}} + global __cuMemsetD2D8_v2 + data["__cuMemsetD2D8_v2"] = __cuMemsetD2D8_v2 + {{else}} + data["__cuMemsetD2D8_v2"] = 0 + {{endif}} + + {{if 'cuMemsetD2D16_v2' in found_functions}} + global __cuMemsetD2D16_v2 + data["__cuMemsetD2D16_v2"] = __cuMemsetD2D16_v2 + {{else}} + data["__cuMemsetD2D16_v2"] = 0 + {{endif}} + + {{if 'cuMemsetD2D32_v2' in found_functions}} + global __cuMemsetD2D32_v2 + data["__cuMemsetD2D32_v2"] = __cuMemsetD2D32_v2 + {{else}} + data["__cuMemsetD2D32_v2"] = 0 + {{endif}} + + {{if 'cuMemsetD8Async' in found_functions}} + global __cuMemsetD8Async + data["__cuMemsetD8Async"] = __cuMemsetD8Async + {{else}} + data["__cuMemsetD8Async"] = 0 + {{endif}} + + {{if 'cuMemsetD16Async' in found_functions}} + global __cuMemsetD16Async + data["__cuMemsetD16Async"] = __cuMemsetD16Async + {{else}} + data["__cuMemsetD16Async"] = 0 + {{endif}} + + {{if 'cuMemsetD32Async' in found_functions}} + global __cuMemsetD32Async + data["__cuMemsetD32Async"] = __cuMemsetD32Async + {{else}} + data["__cuMemsetD32Async"] = 0 + {{endif}} + + {{if 'cuMemsetD2D8Async' in found_functions}} + global __cuMemsetD2D8Async + data["__cuMemsetD2D8Async"] = __cuMemsetD2D8Async + {{else}} + data["__cuMemsetD2D8Async"] = 0 + {{endif}} + + {{if 'cuMemsetD2D16Async' in found_functions}} + global __cuMemsetD2D16Async + data["__cuMemsetD2D16Async"] = __cuMemsetD2D16Async + {{else}} + data["__cuMemsetD2D16Async"] = 0 + {{endif}} + + {{if 'cuMemsetD2D32Async' in found_functions}} + global __cuMemsetD2D32Async + data["__cuMemsetD2D32Async"] = __cuMemsetD2D32Async + {{else}} + data["__cuMemsetD2D32Async"] = 0 + {{endif}} + + {{if 'cuArrayCreate_v2' in found_functions}} + global __cuArrayCreate_v2 + data["__cuArrayCreate_v2"] = __cuArrayCreate_v2 + {{else}} + data["__cuArrayCreate_v2"] = 0 + {{endif}} + + {{if 'cuArrayGetDescriptor_v2' in found_functions}} + global __cuArrayGetDescriptor_v2 + data["__cuArrayGetDescriptor_v2"] = __cuArrayGetDescriptor_v2 + {{else}} + data["__cuArrayGetDescriptor_v2"] = 0 + {{endif}} + + {{if 'cuArrayGetSparseProperties' in found_functions}} + global __cuArrayGetSparseProperties + data["__cuArrayGetSparseProperties"] = __cuArrayGetSparseProperties + {{else}} + data["__cuArrayGetSparseProperties"] = 0 + {{endif}} + + {{if 'cuMipmappedArrayGetSparseProperties' in found_functions}} + global __cuMipmappedArrayGetSparseProperties + data["__cuMipmappedArrayGetSparseProperties"] = __cuMipmappedArrayGetSparseProperties + {{else}} + data["__cuMipmappedArrayGetSparseProperties"] = 0 + {{endif}} + + {{if 'cuArrayGetMemoryRequirements' in found_functions}} + global __cuArrayGetMemoryRequirements + data["__cuArrayGetMemoryRequirements"] = __cuArrayGetMemoryRequirements + {{else}} + data["__cuArrayGetMemoryRequirements"] = 0 + {{endif}} + + {{if 'cuMipmappedArrayGetMemoryRequirements' in found_functions}} + global __cuMipmappedArrayGetMemoryRequirements + data["__cuMipmappedArrayGetMemoryRequirements"] = __cuMipmappedArrayGetMemoryRequirements + {{else}} + data["__cuMipmappedArrayGetMemoryRequirements"] = 0 + {{endif}} + + {{if 'cuArrayGetPlane' in found_functions}} + global __cuArrayGetPlane + data["__cuArrayGetPlane"] = __cuArrayGetPlane + {{else}} + data["__cuArrayGetPlane"] = 0 + {{endif}} + + {{if 'cuArrayDestroy' in found_functions}} + global __cuArrayDestroy + data["__cuArrayDestroy"] = __cuArrayDestroy + {{else}} + data["__cuArrayDestroy"] = 0 + {{endif}} + + {{if 'cuArray3DCreate_v2' in found_functions}} + global __cuArray3DCreate_v2 + data["__cuArray3DCreate_v2"] = __cuArray3DCreate_v2 + {{else}} + data["__cuArray3DCreate_v2"] = 0 + {{endif}} + + {{if 'cuArray3DGetDescriptor_v2' in found_functions}} + global __cuArray3DGetDescriptor_v2 + data["__cuArray3DGetDescriptor_v2"] = __cuArray3DGetDescriptor_v2 + {{else}} + data["__cuArray3DGetDescriptor_v2"] = 0 + {{endif}} + + {{if 'cuMipmappedArrayCreate' in found_functions}} + global __cuMipmappedArrayCreate + data["__cuMipmappedArrayCreate"] = __cuMipmappedArrayCreate + {{else}} + data["__cuMipmappedArrayCreate"] = 0 + {{endif}} + + {{if 'cuMipmappedArrayGetLevel' in found_functions}} + global __cuMipmappedArrayGetLevel + data["__cuMipmappedArrayGetLevel"] = __cuMipmappedArrayGetLevel + {{else}} + data["__cuMipmappedArrayGetLevel"] = 0 + {{endif}} + + {{if 'cuMipmappedArrayDestroy' in found_functions}} + global __cuMipmappedArrayDestroy + data["__cuMipmappedArrayDestroy"] = __cuMipmappedArrayDestroy + {{else}} + data["__cuMipmappedArrayDestroy"] = 0 + {{endif}} + + {{if 'cuMemGetHandleForAddressRange' in found_functions}} + global __cuMemGetHandleForAddressRange + data["__cuMemGetHandleForAddressRange"] = __cuMemGetHandleForAddressRange + {{else}} + data["__cuMemGetHandleForAddressRange"] = 0 + {{endif}} + + {{if 'cuMemBatchDecompressAsync' in found_functions}} + global __cuMemBatchDecompressAsync + data["__cuMemBatchDecompressAsync"] = __cuMemBatchDecompressAsync + {{else}} + data["__cuMemBatchDecompressAsync"] = 0 + {{endif}} + + {{if 'cuMemAddressReserve' in found_functions}} + global __cuMemAddressReserve + data["__cuMemAddressReserve"] = __cuMemAddressReserve + {{else}} + data["__cuMemAddressReserve"] = 0 + {{endif}} + + {{if 'cuMemAddressFree' in found_functions}} + global __cuMemAddressFree + data["__cuMemAddressFree"] = __cuMemAddressFree + {{else}} + data["__cuMemAddressFree"] = 0 + {{endif}} + + {{if 'cuMemCreate' in found_functions}} + global __cuMemCreate + data["__cuMemCreate"] = __cuMemCreate + {{else}} + data["__cuMemCreate"] = 0 + {{endif}} + + {{if 'cuMemRelease' in found_functions}} + global __cuMemRelease + data["__cuMemRelease"] = __cuMemRelease + {{else}} + data["__cuMemRelease"] = 0 + {{endif}} + + {{if 'cuMemMap' in found_functions}} + global __cuMemMap + data["__cuMemMap"] = __cuMemMap + {{else}} + data["__cuMemMap"] = 0 + {{endif}} + + {{if 'cuMemMapArrayAsync' in found_functions}} + global __cuMemMapArrayAsync + data["__cuMemMapArrayAsync"] = __cuMemMapArrayAsync + {{else}} + data["__cuMemMapArrayAsync"] = 0 + {{endif}} + + {{if 'cuMemUnmap' in found_functions}} + global __cuMemUnmap + data["__cuMemUnmap"] = __cuMemUnmap + {{else}} + data["__cuMemUnmap"] = 0 + {{endif}} + + {{if 'cuMemSetAccess' in found_functions}} + global __cuMemSetAccess + data["__cuMemSetAccess"] = __cuMemSetAccess + {{else}} + data["__cuMemSetAccess"] = 0 + {{endif}} + + {{if 'cuMemGetAccess' in found_functions}} + global __cuMemGetAccess + data["__cuMemGetAccess"] = __cuMemGetAccess + {{else}} + data["__cuMemGetAccess"] = 0 + {{endif}} + + {{if 'cuMemExportToShareableHandle' in found_functions}} + global __cuMemExportToShareableHandle + data["__cuMemExportToShareableHandle"] = __cuMemExportToShareableHandle + {{else}} + data["__cuMemExportToShareableHandle"] = 0 + {{endif}} + + {{if 'cuMemImportFromShareableHandle' in found_functions}} + global __cuMemImportFromShareableHandle + data["__cuMemImportFromShareableHandle"] = __cuMemImportFromShareableHandle + {{else}} + data["__cuMemImportFromShareableHandle"] = 0 + {{endif}} + + {{if 'cuMemGetAllocationGranularity' in found_functions}} + global __cuMemGetAllocationGranularity + data["__cuMemGetAllocationGranularity"] = __cuMemGetAllocationGranularity + {{else}} + data["__cuMemGetAllocationGranularity"] = 0 + {{endif}} + + {{if 'cuMemGetAllocationPropertiesFromHandle' in found_functions}} + global __cuMemGetAllocationPropertiesFromHandle + data["__cuMemGetAllocationPropertiesFromHandle"] = __cuMemGetAllocationPropertiesFromHandle + {{else}} + data["__cuMemGetAllocationPropertiesFromHandle"] = 0 + {{endif}} + + {{if 'cuMemRetainAllocationHandle' in found_functions}} + global __cuMemRetainAllocationHandle + data["__cuMemRetainAllocationHandle"] = __cuMemRetainAllocationHandle + {{else}} + data["__cuMemRetainAllocationHandle"] = 0 + {{endif}} + + {{if 'cuMemFreeAsync' in found_functions}} + global __cuMemFreeAsync + data["__cuMemFreeAsync"] = __cuMemFreeAsync + {{else}} + data["__cuMemFreeAsync"] = 0 + {{endif}} + + {{if 'cuMemAllocAsync' in found_functions}} + global __cuMemAllocAsync + data["__cuMemAllocAsync"] = __cuMemAllocAsync + {{else}} + data["__cuMemAllocAsync"] = 0 + {{endif}} + + {{if 'cuMemPoolTrimTo' in found_functions}} + global __cuMemPoolTrimTo + data["__cuMemPoolTrimTo"] = __cuMemPoolTrimTo + {{else}} + data["__cuMemPoolTrimTo"] = 0 + {{endif}} + + {{if 'cuMemPoolSetAttribute' in found_functions}} + global __cuMemPoolSetAttribute + data["__cuMemPoolSetAttribute"] = __cuMemPoolSetAttribute + {{else}} + data["__cuMemPoolSetAttribute"] = 0 + {{endif}} + + {{if 'cuMemPoolGetAttribute' in found_functions}} + global __cuMemPoolGetAttribute + data["__cuMemPoolGetAttribute"] = __cuMemPoolGetAttribute + {{else}} + data["__cuMemPoolGetAttribute"] = 0 + {{endif}} + + {{if 'cuMemPoolSetAccess' in found_functions}} + global __cuMemPoolSetAccess + data["__cuMemPoolSetAccess"] = __cuMemPoolSetAccess + {{else}} + data["__cuMemPoolSetAccess"] = 0 + {{endif}} + + {{if 'cuMemPoolGetAccess' in found_functions}} + global __cuMemPoolGetAccess + data["__cuMemPoolGetAccess"] = __cuMemPoolGetAccess + {{else}} + data["__cuMemPoolGetAccess"] = 0 + {{endif}} + + {{if 'cuMemPoolCreate' in found_functions}} + global __cuMemPoolCreate + data["__cuMemPoolCreate"] = __cuMemPoolCreate + {{else}} + data["__cuMemPoolCreate"] = 0 + {{endif}} + + {{if 'cuMemPoolDestroy' in found_functions}} + global __cuMemPoolDestroy + data["__cuMemPoolDestroy"] = __cuMemPoolDestroy + {{else}} + data["__cuMemPoolDestroy"] = 0 + {{endif}} + + {{if 'cuMemAllocFromPoolAsync' in found_functions}} + global __cuMemAllocFromPoolAsync + data["__cuMemAllocFromPoolAsync"] = __cuMemAllocFromPoolAsync + {{else}} + data["__cuMemAllocFromPoolAsync"] = 0 + {{endif}} + + {{if 'cuMemPoolExportToShareableHandle' in found_functions}} + global __cuMemPoolExportToShareableHandle + data["__cuMemPoolExportToShareableHandle"] = __cuMemPoolExportToShareableHandle + {{else}} + data["__cuMemPoolExportToShareableHandle"] = 0 + {{endif}} + + {{if 'cuMemPoolImportFromShareableHandle' in found_functions}} + global __cuMemPoolImportFromShareableHandle + data["__cuMemPoolImportFromShareableHandle"] = __cuMemPoolImportFromShareableHandle + {{else}} + data["__cuMemPoolImportFromShareableHandle"] = 0 + {{endif}} + + {{if 'cuMemPoolExportPointer' in found_functions}} + global __cuMemPoolExportPointer + data["__cuMemPoolExportPointer"] = __cuMemPoolExportPointer + {{else}} + data["__cuMemPoolExportPointer"] = 0 + {{endif}} + + {{if 'cuMemPoolImportPointer' in found_functions}} + global __cuMemPoolImportPointer + data["__cuMemPoolImportPointer"] = __cuMemPoolImportPointer + {{else}} + data["__cuMemPoolImportPointer"] = 0 + {{endif}} + + {{if 'cuMulticastCreate' in found_functions}} + global __cuMulticastCreate + data["__cuMulticastCreate"] = __cuMulticastCreate + {{else}} + data["__cuMulticastCreate"] = 0 + {{endif}} + + {{if 'cuMulticastAddDevice' in found_functions}} + global __cuMulticastAddDevice + data["__cuMulticastAddDevice"] = __cuMulticastAddDevice + {{else}} + data["__cuMulticastAddDevice"] = 0 + {{endif}} + + {{if 'cuMulticastBindMem' in found_functions}} + global __cuMulticastBindMem + data["__cuMulticastBindMem"] = __cuMulticastBindMem + {{else}} + data["__cuMulticastBindMem"] = 0 + {{endif}} + + {{if 'cuMulticastBindAddr' in found_functions}} + global __cuMulticastBindAddr + data["__cuMulticastBindAddr"] = __cuMulticastBindAddr + {{else}} + data["__cuMulticastBindAddr"] = 0 + {{endif}} + + {{if 'cuMulticastUnbind' in found_functions}} + global __cuMulticastUnbind + data["__cuMulticastUnbind"] = __cuMulticastUnbind + {{else}} + data["__cuMulticastUnbind"] = 0 + {{endif}} + + {{if 'cuMulticastGetGranularity' in found_functions}} + global __cuMulticastGetGranularity + data["__cuMulticastGetGranularity"] = __cuMulticastGetGranularity + {{else}} + data["__cuMulticastGetGranularity"] = 0 + {{endif}} + + {{if 'cuPointerGetAttribute' in found_functions}} + global __cuPointerGetAttribute + data["__cuPointerGetAttribute"] = __cuPointerGetAttribute + {{else}} + data["__cuPointerGetAttribute"] = 0 + {{endif}} + + {{if 'cuMemPrefetchAsync' in found_functions}} + global __cuMemPrefetchAsync + data["__cuMemPrefetchAsync"] = __cuMemPrefetchAsync + {{else}} + data["__cuMemPrefetchAsync"] = 0 + {{endif}} + + {{if 'cuMemPrefetchAsync_v2' in found_functions}} + global __cuMemPrefetchAsync_v2 + data["__cuMemPrefetchAsync_v2"] = __cuMemPrefetchAsync_v2 + {{else}} + data["__cuMemPrefetchAsync_v2"] = 0 + {{endif}} + + {{if 'cuMemAdvise' in found_functions}} + global __cuMemAdvise + data["__cuMemAdvise"] = __cuMemAdvise + {{else}} + data["__cuMemAdvise"] = 0 + {{endif}} + + {{if 'cuMemAdvise_v2' in found_functions}} + global __cuMemAdvise_v2 + data["__cuMemAdvise_v2"] = __cuMemAdvise_v2 + {{else}} + data["__cuMemAdvise_v2"] = 0 + {{endif}} + + {{if 'cuMemRangeGetAttribute' in found_functions}} + global __cuMemRangeGetAttribute + data["__cuMemRangeGetAttribute"] = __cuMemRangeGetAttribute + {{else}} + data["__cuMemRangeGetAttribute"] = 0 + {{endif}} + + {{if 'cuMemRangeGetAttributes' in found_functions}} + global __cuMemRangeGetAttributes + data["__cuMemRangeGetAttributes"] = __cuMemRangeGetAttributes + {{else}} + data["__cuMemRangeGetAttributes"] = 0 + {{endif}} + + {{if 'cuPointerSetAttribute' in found_functions}} + global __cuPointerSetAttribute + data["__cuPointerSetAttribute"] = __cuPointerSetAttribute + {{else}} + data["__cuPointerSetAttribute"] = 0 + {{endif}} + + {{if 'cuPointerGetAttributes' in found_functions}} + global __cuPointerGetAttributes + data["__cuPointerGetAttributes"] = __cuPointerGetAttributes + {{else}} + data["__cuPointerGetAttributes"] = 0 + {{endif}} + + {{if 'cuStreamCreate' in found_functions}} + global __cuStreamCreate + data["__cuStreamCreate"] = __cuStreamCreate + {{else}} + data["__cuStreamCreate"] = 0 + {{endif}} + + {{if 'cuStreamCreateWithPriority' in found_functions}} + global __cuStreamCreateWithPriority + data["__cuStreamCreateWithPriority"] = __cuStreamCreateWithPriority + {{else}} + data["__cuStreamCreateWithPriority"] = 0 + {{endif}} + + {{if 'cuStreamGetPriority' in found_functions}} + global __cuStreamGetPriority + data["__cuStreamGetPriority"] = __cuStreamGetPriority + {{else}} + data["__cuStreamGetPriority"] = 0 + {{endif}} + + {{if 'cuStreamGetDevice' in found_functions}} + global __cuStreamGetDevice + data["__cuStreamGetDevice"] = __cuStreamGetDevice + {{else}} + data["__cuStreamGetDevice"] = 0 + {{endif}} + + {{if 'cuStreamGetFlags' in found_functions}} + global __cuStreamGetFlags + data["__cuStreamGetFlags"] = __cuStreamGetFlags + {{else}} + data["__cuStreamGetFlags"] = 0 + {{endif}} + + {{if 'cuStreamGetId' in found_functions}} + global __cuStreamGetId + data["__cuStreamGetId"] = __cuStreamGetId + {{else}} + data["__cuStreamGetId"] = 0 + {{endif}} + + {{if 'cuStreamGetCtx' in found_functions}} + global __cuStreamGetCtx + data["__cuStreamGetCtx"] = __cuStreamGetCtx + {{else}} + data["__cuStreamGetCtx"] = 0 + {{endif}} + + {{if 'cuStreamGetCtx_v2' in found_functions}} + global __cuStreamGetCtx_v2 + data["__cuStreamGetCtx_v2"] = __cuStreamGetCtx_v2 + {{else}} + data["__cuStreamGetCtx_v2"] = 0 + {{endif}} + + {{if 'cuStreamWaitEvent' in found_functions}} + global __cuStreamWaitEvent + data["__cuStreamWaitEvent"] = __cuStreamWaitEvent + {{else}} + data["__cuStreamWaitEvent"] = 0 + {{endif}} + + {{if 'cuStreamAddCallback' in found_functions}} + global __cuStreamAddCallback + data["__cuStreamAddCallback"] = __cuStreamAddCallback + {{else}} + data["__cuStreamAddCallback"] = 0 + {{endif}} + + {{if 'cuStreamBeginCapture_v2' in found_functions}} + global __cuStreamBeginCapture_v2 + data["__cuStreamBeginCapture_v2"] = __cuStreamBeginCapture_v2 + {{else}} + data["__cuStreamBeginCapture_v2"] = 0 + {{endif}} + + {{if 'cuStreamBeginCaptureToGraph' in found_functions}} + global __cuStreamBeginCaptureToGraph + data["__cuStreamBeginCaptureToGraph"] = __cuStreamBeginCaptureToGraph + {{else}} + data["__cuStreamBeginCaptureToGraph"] = 0 + {{endif}} + + {{if 'cuThreadExchangeStreamCaptureMode' in found_functions}} + global __cuThreadExchangeStreamCaptureMode + data["__cuThreadExchangeStreamCaptureMode"] = __cuThreadExchangeStreamCaptureMode + {{else}} + data["__cuThreadExchangeStreamCaptureMode"] = 0 + {{endif}} + + {{if 'cuStreamEndCapture' in found_functions}} + global __cuStreamEndCapture + data["__cuStreamEndCapture"] = __cuStreamEndCapture + {{else}} + data["__cuStreamEndCapture"] = 0 + {{endif}} + + {{if 'cuStreamIsCapturing' in found_functions}} + global __cuStreamIsCapturing + data["__cuStreamIsCapturing"] = __cuStreamIsCapturing + {{else}} + data["__cuStreamIsCapturing"] = 0 + {{endif}} + + {{if 'cuStreamGetCaptureInfo_v2' in found_functions}} + global __cuStreamGetCaptureInfo_v2 + data["__cuStreamGetCaptureInfo_v2"] = __cuStreamGetCaptureInfo_v2 + {{else}} + data["__cuStreamGetCaptureInfo_v2"] = 0 + {{endif}} + + {{if 'cuStreamGetCaptureInfo_v3' in found_functions}} + global __cuStreamGetCaptureInfo_v3 + data["__cuStreamGetCaptureInfo_v3"] = __cuStreamGetCaptureInfo_v3 + {{else}} + data["__cuStreamGetCaptureInfo_v3"] = 0 + {{endif}} + + {{if 'cuStreamUpdateCaptureDependencies' in found_functions}} + global __cuStreamUpdateCaptureDependencies + data["__cuStreamUpdateCaptureDependencies"] = __cuStreamUpdateCaptureDependencies + {{else}} + data["__cuStreamUpdateCaptureDependencies"] = 0 + {{endif}} + + {{if 'cuStreamUpdateCaptureDependencies_v2' in found_functions}} + global __cuStreamUpdateCaptureDependencies_v2 + data["__cuStreamUpdateCaptureDependencies_v2"] = __cuStreamUpdateCaptureDependencies_v2 + {{else}} + data["__cuStreamUpdateCaptureDependencies_v2"] = 0 + {{endif}} + + {{if 'cuStreamAttachMemAsync' in found_functions}} + global __cuStreamAttachMemAsync + data["__cuStreamAttachMemAsync"] = __cuStreamAttachMemAsync + {{else}} + data["__cuStreamAttachMemAsync"] = 0 + {{endif}} + + {{if 'cuStreamQuery' in found_functions}} + global __cuStreamQuery + data["__cuStreamQuery"] = __cuStreamQuery + {{else}} + data["__cuStreamQuery"] = 0 + {{endif}} + + {{if 'cuStreamSynchronize' in found_functions}} + global __cuStreamSynchronize + data["__cuStreamSynchronize"] = __cuStreamSynchronize + {{else}} + data["__cuStreamSynchronize"] = 0 + {{endif}} + + {{if 'cuStreamDestroy_v2' in found_functions}} + global __cuStreamDestroy_v2 + data["__cuStreamDestroy_v2"] = __cuStreamDestroy_v2 + {{else}} + data["__cuStreamDestroy_v2"] = 0 + {{endif}} + + {{if 'cuStreamCopyAttributes' in found_functions}} + global __cuStreamCopyAttributes + data["__cuStreamCopyAttributes"] = __cuStreamCopyAttributes + {{else}} + data["__cuStreamCopyAttributes"] = 0 + {{endif}} + + {{if 'cuStreamGetAttribute' in found_functions}} + global __cuStreamGetAttribute + data["__cuStreamGetAttribute"] = __cuStreamGetAttribute + {{else}} + data["__cuStreamGetAttribute"] = 0 + {{endif}} + + {{if 'cuStreamSetAttribute' in found_functions}} + global __cuStreamSetAttribute + data["__cuStreamSetAttribute"] = __cuStreamSetAttribute + {{else}} + data["__cuStreamSetAttribute"] = 0 + {{endif}} + + {{if 'cuEventCreate' in found_functions}} + global __cuEventCreate + data["__cuEventCreate"] = __cuEventCreate + {{else}} + data["__cuEventCreate"] = 0 + {{endif}} + + {{if 'cuEventRecord' in found_functions}} + global __cuEventRecord + data["__cuEventRecord"] = __cuEventRecord + {{else}} + data["__cuEventRecord"] = 0 + {{endif}} + + {{if 'cuEventRecordWithFlags' in found_functions}} + global __cuEventRecordWithFlags + data["__cuEventRecordWithFlags"] = __cuEventRecordWithFlags + {{else}} + data["__cuEventRecordWithFlags"] = 0 + {{endif}} + + {{if 'cuEventQuery' in found_functions}} + global __cuEventQuery + data["__cuEventQuery"] = __cuEventQuery + {{else}} + data["__cuEventQuery"] = 0 + {{endif}} + + {{if 'cuEventSynchronize' in found_functions}} + global __cuEventSynchronize + data["__cuEventSynchronize"] = __cuEventSynchronize + {{else}} + data["__cuEventSynchronize"] = 0 + {{endif}} + + {{if 'cuEventDestroy_v2' in found_functions}} + global __cuEventDestroy_v2 + data["__cuEventDestroy_v2"] = __cuEventDestroy_v2 + {{else}} + data["__cuEventDestroy_v2"] = 0 + {{endif}} + + {{if 'cuEventElapsedTime' in found_functions}} + global __cuEventElapsedTime + data["__cuEventElapsedTime"] = __cuEventElapsedTime + {{else}} + data["__cuEventElapsedTime"] = 0 + {{endif}} + + {{if 'cuEventElapsedTime_v2' in found_functions}} + global __cuEventElapsedTime_v2 + data["__cuEventElapsedTime_v2"] = __cuEventElapsedTime_v2 + {{else}} + data["__cuEventElapsedTime_v2"] = 0 + {{endif}} + + {{if 'cuImportExternalMemory' in found_functions}} + global __cuImportExternalMemory + data["__cuImportExternalMemory"] = __cuImportExternalMemory + {{else}} + data["__cuImportExternalMemory"] = 0 + {{endif}} + + {{if 'cuExternalMemoryGetMappedBuffer' in found_functions}} + global __cuExternalMemoryGetMappedBuffer + data["__cuExternalMemoryGetMappedBuffer"] = __cuExternalMemoryGetMappedBuffer + {{else}} + data["__cuExternalMemoryGetMappedBuffer"] = 0 + {{endif}} + + {{if 'cuExternalMemoryGetMappedMipmappedArray' in found_functions}} + global __cuExternalMemoryGetMappedMipmappedArray + data["__cuExternalMemoryGetMappedMipmappedArray"] = __cuExternalMemoryGetMappedMipmappedArray + {{else}} + data["__cuExternalMemoryGetMappedMipmappedArray"] = 0 + {{endif}} + + {{if 'cuDestroyExternalMemory' in found_functions}} + global __cuDestroyExternalMemory + data["__cuDestroyExternalMemory"] = __cuDestroyExternalMemory + {{else}} + data["__cuDestroyExternalMemory"] = 0 + {{endif}} + + {{if 'cuImportExternalSemaphore' in found_functions}} + global __cuImportExternalSemaphore + data["__cuImportExternalSemaphore"] = __cuImportExternalSemaphore + {{else}} + data["__cuImportExternalSemaphore"] = 0 + {{endif}} + + {{if 'cuSignalExternalSemaphoresAsync' in found_functions}} + global __cuSignalExternalSemaphoresAsync + data["__cuSignalExternalSemaphoresAsync"] = __cuSignalExternalSemaphoresAsync + {{else}} + data["__cuSignalExternalSemaphoresAsync"] = 0 + {{endif}} + + {{if 'cuWaitExternalSemaphoresAsync' in found_functions}} + global __cuWaitExternalSemaphoresAsync + data["__cuWaitExternalSemaphoresAsync"] = __cuWaitExternalSemaphoresAsync + {{else}} + data["__cuWaitExternalSemaphoresAsync"] = 0 + {{endif}} + + {{if 'cuDestroyExternalSemaphore' in found_functions}} + global __cuDestroyExternalSemaphore + data["__cuDestroyExternalSemaphore"] = __cuDestroyExternalSemaphore + {{else}} + data["__cuDestroyExternalSemaphore"] = 0 + {{endif}} + + {{if 'cuStreamWaitValue32_v2' in found_functions}} + global __cuStreamWaitValue32_v2 + data["__cuStreamWaitValue32_v2"] = __cuStreamWaitValue32_v2 + {{else}} + data["__cuStreamWaitValue32_v2"] = 0 + {{endif}} + + {{if 'cuStreamWaitValue64_v2' in found_functions}} + global __cuStreamWaitValue64_v2 + data["__cuStreamWaitValue64_v2"] = __cuStreamWaitValue64_v2 + {{else}} + data["__cuStreamWaitValue64_v2"] = 0 + {{endif}} + + {{if 'cuStreamWriteValue32_v2' in found_functions}} + global __cuStreamWriteValue32_v2 + data["__cuStreamWriteValue32_v2"] = __cuStreamWriteValue32_v2 + {{else}} + data["__cuStreamWriteValue32_v2"] = 0 + {{endif}} + + {{if 'cuStreamWriteValue64_v2' in found_functions}} + global __cuStreamWriteValue64_v2 + data["__cuStreamWriteValue64_v2"] = __cuStreamWriteValue64_v2 + {{else}} + data["__cuStreamWriteValue64_v2"] = 0 + {{endif}} + + {{if 'cuStreamBatchMemOp_v2' in found_functions}} + global __cuStreamBatchMemOp_v2 + data["__cuStreamBatchMemOp_v2"] = __cuStreamBatchMemOp_v2 + {{else}} + data["__cuStreamBatchMemOp_v2"] = 0 + {{endif}} + + {{if 'cuFuncGetAttribute' in found_functions}} + global __cuFuncGetAttribute + data["__cuFuncGetAttribute"] = __cuFuncGetAttribute + {{else}} + data["__cuFuncGetAttribute"] = 0 + {{endif}} + + {{if 'cuFuncSetAttribute' in found_functions}} + global __cuFuncSetAttribute + data["__cuFuncSetAttribute"] = __cuFuncSetAttribute + {{else}} + data["__cuFuncSetAttribute"] = 0 + {{endif}} + + {{if 'cuFuncSetCacheConfig' in found_functions}} + global __cuFuncSetCacheConfig + data["__cuFuncSetCacheConfig"] = __cuFuncSetCacheConfig + {{else}} + data["__cuFuncSetCacheConfig"] = 0 + {{endif}} + + {{if 'cuFuncGetModule' in found_functions}} + global __cuFuncGetModule + data["__cuFuncGetModule"] = __cuFuncGetModule + {{else}} + data["__cuFuncGetModule"] = 0 + {{endif}} + + {{if 'cuFuncGetName' in found_functions}} + global __cuFuncGetName + data["__cuFuncGetName"] = __cuFuncGetName + {{else}} + data["__cuFuncGetName"] = 0 + {{endif}} + + {{if 'cuFuncGetParamInfo' in found_functions}} + global __cuFuncGetParamInfo + data["__cuFuncGetParamInfo"] = __cuFuncGetParamInfo + {{else}} + data["__cuFuncGetParamInfo"] = 0 + {{endif}} + + {{if 'cuFuncIsLoaded' in found_functions}} + global __cuFuncIsLoaded + data["__cuFuncIsLoaded"] = __cuFuncIsLoaded + {{else}} + data["__cuFuncIsLoaded"] = 0 + {{endif}} + + {{if 'cuFuncLoad' in found_functions}} + global __cuFuncLoad + data["__cuFuncLoad"] = __cuFuncLoad + {{else}} + data["__cuFuncLoad"] = 0 + {{endif}} + + {{if 'cuLaunchKernel' in found_functions}} + global __cuLaunchKernel + data["__cuLaunchKernel"] = __cuLaunchKernel + {{else}} + data["__cuLaunchKernel"] = 0 + {{endif}} + + {{if 'cuLaunchKernelEx' in found_functions}} + global __cuLaunchKernelEx + data["__cuLaunchKernelEx"] = __cuLaunchKernelEx + {{else}} + data["__cuLaunchKernelEx"] = 0 + {{endif}} + + {{if 'cuLaunchCooperativeKernel' in found_functions}} + global __cuLaunchCooperativeKernel + data["__cuLaunchCooperativeKernel"] = __cuLaunchCooperativeKernel + {{else}} + data["__cuLaunchCooperativeKernel"] = 0 + {{endif}} + + {{if 'cuLaunchCooperativeKernelMultiDevice' in found_functions}} + global __cuLaunchCooperativeKernelMultiDevice + data["__cuLaunchCooperativeKernelMultiDevice"] = __cuLaunchCooperativeKernelMultiDevice + {{else}} + data["__cuLaunchCooperativeKernelMultiDevice"] = 0 + {{endif}} + + {{if 'cuLaunchHostFunc' in found_functions}} + global __cuLaunchHostFunc + data["__cuLaunchHostFunc"] = __cuLaunchHostFunc + {{else}} + data["__cuLaunchHostFunc"] = 0 + {{endif}} + + {{if 'cuFuncSetBlockShape' in found_functions}} + global __cuFuncSetBlockShape + data["__cuFuncSetBlockShape"] = __cuFuncSetBlockShape + {{else}} + data["__cuFuncSetBlockShape"] = 0 + {{endif}} + + {{if 'cuFuncSetSharedSize' in found_functions}} + global __cuFuncSetSharedSize + data["__cuFuncSetSharedSize"] = __cuFuncSetSharedSize + {{else}} + data["__cuFuncSetSharedSize"] = 0 + {{endif}} + + {{if 'cuParamSetSize' in found_functions}} + global __cuParamSetSize + data["__cuParamSetSize"] = __cuParamSetSize + {{else}} + data["__cuParamSetSize"] = 0 + {{endif}} + + {{if 'cuParamSeti' in found_functions}} + global __cuParamSeti + data["__cuParamSeti"] = __cuParamSeti + {{else}} + data["__cuParamSeti"] = 0 + {{endif}} + + {{if 'cuParamSetf' in found_functions}} + global __cuParamSetf + data["__cuParamSetf"] = __cuParamSetf + {{else}} + data["__cuParamSetf"] = 0 + {{endif}} + + {{if 'cuParamSetv' in found_functions}} + global __cuParamSetv + data["__cuParamSetv"] = __cuParamSetv + {{else}} + data["__cuParamSetv"] = 0 + {{endif}} + + {{if 'cuLaunch' in found_functions}} + global __cuLaunch + data["__cuLaunch"] = __cuLaunch + {{else}} + data["__cuLaunch"] = 0 + {{endif}} + + {{if 'cuLaunchGrid' in found_functions}} + global __cuLaunchGrid + data["__cuLaunchGrid"] = __cuLaunchGrid + {{else}} + data["__cuLaunchGrid"] = 0 + {{endif}} + + {{if 'cuLaunchGridAsync' in found_functions}} + global __cuLaunchGridAsync + data["__cuLaunchGridAsync"] = __cuLaunchGridAsync + {{else}} + data["__cuLaunchGridAsync"] = 0 + {{endif}} + + {{if 'cuParamSetTexRef' in found_functions}} + global __cuParamSetTexRef + data["__cuParamSetTexRef"] = __cuParamSetTexRef + {{else}} + data["__cuParamSetTexRef"] = 0 + {{endif}} + + {{if 'cuFuncSetSharedMemConfig' in found_functions}} + global __cuFuncSetSharedMemConfig + data["__cuFuncSetSharedMemConfig"] = __cuFuncSetSharedMemConfig + {{else}} + data["__cuFuncSetSharedMemConfig"] = 0 + {{endif}} + + {{if 'cuGraphCreate' in found_functions}} + global __cuGraphCreate + data["__cuGraphCreate"] = __cuGraphCreate + {{else}} + data["__cuGraphCreate"] = 0 + {{endif}} + + {{if 'cuGraphAddKernelNode_v2' in found_functions}} + global __cuGraphAddKernelNode_v2 + data["__cuGraphAddKernelNode_v2"] = __cuGraphAddKernelNode_v2 + {{else}} + data["__cuGraphAddKernelNode_v2"] = 0 + {{endif}} + + {{if 'cuGraphKernelNodeGetParams_v2' in found_functions}} + global __cuGraphKernelNodeGetParams_v2 + data["__cuGraphKernelNodeGetParams_v2"] = __cuGraphKernelNodeGetParams_v2 + {{else}} + data["__cuGraphKernelNodeGetParams_v2"] = 0 + {{endif}} + + {{if 'cuGraphKernelNodeSetParams_v2' in found_functions}} + global __cuGraphKernelNodeSetParams_v2 + data["__cuGraphKernelNodeSetParams_v2"] = __cuGraphKernelNodeSetParams_v2 + {{else}} + data["__cuGraphKernelNodeSetParams_v2"] = 0 + {{endif}} + + {{if 'cuGraphAddMemcpyNode' in found_functions}} + global __cuGraphAddMemcpyNode + data["__cuGraphAddMemcpyNode"] = __cuGraphAddMemcpyNode + {{else}} + data["__cuGraphAddMemcpyNode"] = 0 + {{endif}} + + {{if 'cuGraphMemcpyNodeGetParams' in found_functions}} + global __cuGraphMemcpyNodeGetParams + data["__cuGraphMemcpyNodeGetParams"] = __cuGraphMemcpyNodeGetParams + {{else}} + data["__cuGraphMemcpyNodeGetParams"] = 0 + {{endif}} + + {{if 'cuGraphMemcpyNodeSetParams' in found_functions}} + global __cuGraphMemcpyNodeSetParams + data["__cuGraphMemcpyNodeSetParams"] = __cuGraphMemcpyNodeSetParams + {{else}} + data["__cuGraphMemcpyNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphAddMemsetNode' in found_functions}} + global __cuGraphAddMemsetNode + data["__cuGraphAddMemsetNode"] = __cuGraphAddMemsetNode + {{else}} + data["__cuGraphAddMemsetNode"] = 0 + {{endif}} + + {{if 'cuGraphMemsetNodeGetParams' in found_functions}} + global __cuGraphMemsetNodeGetParams + data["__cuGraphMemsetNodeGetParams"] = __cuGraphMemsetNodeGetParams + {{else}} + data["__cuGraphMemsetNodeGetParams"] = 0 + {{endif}} + + {{if 'cuGraphMemsetNodeSetParams' in found_functions}} + global __cuGraphMemsetNodeSetParams + data["__cuGraphMemsetNodeSetParams"] = __cuGraphMemsetNodeSetParams + {{else}} + data["__cuGraphMemsetNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphAddHostNode' in found_functions}} + global __cuGraphAddHostNode + data["__cuGraphAddHostNode"] = __cuGraphAddHostNode + {{else}} + data["__cuGraphAddHostNode"] = 0 + {{endif}} + + {{if 'cuGraphHostNodeGetParams' in found_functions}} + global __cuGraphHostNodeGetParams + data["__cuGraphHostNodeGetParams"] = __cuGraphHostNodeGetParams + {{else}} + data["__cuGraphHostNodeGetParams"] = 0 + {{endif}} + + {{if 'cuGraphHostNodeSetParams' in found_functions}} + global __cuGraphHostNodeSetParams + data["__cuGraphHostNodeSetParams"] = __cuGraphHostNodeSetParams + {{else}} + data["__cuGraphHostNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphAddChildGraphNode' in found_functions}} + global __cuGraphAddChildGraphNode + data["__cuGraphAddChildGraphNode"] = __cuGraphAddChildGraphNode + {{else}} + data["__cuGraphAddChildGraphNode"] = 0 + {{endif}} + + {{if 'cuGraphChildGraphNodeGetGraph' in found_functions}} + global __cuGraphChildGraphNodeGetGraph + data["__cuGraphChildGraphNodeGetGraph"] = __cuGraphChildGraphNodeGetGraph + {{else}} + data["__cuGraphChildGraphNodeGetGraph"] = 0 + {{endif}} + + {{if 'cuGraphAddEmptyNode' in found_functions}} + global __cuGraphAddEmptyNode + data["__cuGraphAddEmptyNode"] = __cuGraphAddEmptyNode + {{else}} + data["__cuGraphAddEmptyNode"] = 0 + {{endif}} + + {{if 'cuGraphAddEventRecordNode' in found_functions}} + global __cuGraphAddEventRecordNode + data["__cuGraphAddEventRecordNode"] = __cuGraphAddEventRecordNode + {{else}} + data["__cuGraphAddEventRecordNode"] = 0 + {{endif}} + + {{if 'cuGraphEventRecordNodeGetEvent' in found_functions}} + global __cuGraphEventRecordNodeGetEvent + data["__cuGraphEventRecordNodeGetEvent"] = __cuGraphEventRecordNodeGetEvent + {{else}} + data["__cuGraphEventRecordNodeGetEvent"] = 0 + {{endif}} + + {{if 'cuGraphEventRecordNodeSetEvent' in found_functions}} + global __cuGraphEventRecordNodeSetEvent + data["__cuGraphEventRecordNodeSetEvent"] = __cuGraphEventRecordNodeSetEvent + {{else}} + data["__cuGraphEventRecordNodeSetEvent"] = 0 + {{endif}} + + {{if 'cuGraphAddEventWaitNode' in found_functions}} + global __cuGraphAddEventWaitNode + data["__cuGraphAddEventWaitNode"] = __cuGraphAddEventWaitNode + {{else}} + data["__cuGraphAddEventWaitNode"] = 0 + {{endif}} + + {{if 'cuGraphEventWaitNodeGetEvent' in found_functions}} + global __cuGraphEventWaitNodeGetEvent + data["__cuGraphEventWaitNodeGetEvent"] = __cuGraphEventWaitNodeGetEvent + {{else}} + data["__cuGraphEventWaitNodeGetEvent"] = 0 + {{endif}} + + {{if 'cuGraphEventWaitNodeSetEvent' in found_functions}} + global __cuGraphEventWaitNodeSetEvent + data["__cuGraphEventWaitNodeSetEvent"] = __cuGraphEventWaitNodeSetEvent + {{else}} + data["__cuGraphEventWaitNodeSetEvent"] = 0 + {{endif}} + + {{if 'cuGraphAddExternalSemaphoresSignalNode' in found_functions}} + global __cuGraphAddExternalSemaphoresSignalNode + data["__cuGraphAddExternalSemaphoresSignalNode"] = __cuGraphAddExternalSemaphoresSignalNode + {{else}} + data["__cuGraphAddExternalSemaphoresSignalNode"] = 0 + {{endif}} + + {{if 'cuGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} + global __cuGraphExternalSemaphoresSignalNodeGetParams + data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = __cuGraphExternalSemaphoresSignalNodeGetParams + {{else}} + data["__cuGraphExternalSemaphoresSignalNodeGetParams"] = 0 + {{endif}} + + {{if 'cuGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} + global __cuGraphExternalSemaphoresSignalNodeSetParams + data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = __cuGraphExternalSemaphoresSignalNodeSetParams + {{else}} + data["__cuGraphExternalSemaphoresSignalNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphAddExternalSemaphoresWaitNode' in found_functions}} + global __cuGraphAddExternalSemaphoresWaitNode + data["__cuGraphAddExternalSemaphoresWaitNode"] = __cuGraphAddExternalSemaphoresWaitNode + {{else}} + data["__cuGraphAddExternalSemaphoresWaitNode"] = 0 + {{endif}} + + {{if 'cuGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} + global __cuGraphExternalSemaphoresWaitNodeGetParams + data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = __cuGraphExternalSemaphoresWaitNodeGetParams + {{else}} + data["__cuGraphExternalSemaphoresWaitNodeGetParams"] = 0 + {{endif}} + + {{if 'cuGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} + global __cuGraphExternalSemaphoresWaitNodeSetParams + data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = __cuGraphExternalSemaphoresWaitNodeSetParams + {{else}} + data["__cuGraphExternalSemaphoresWaitNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphAddBatchMemOpNode' in found_functions}} + global __cuGraphAddBatchMemOpNode + data["__cuGraphAddBatchMemOpNode"] = __cuGraphAddBatchMemOpNode + {{else}} + data["__cuGraphAddBatchMemOpNode"] = 0 + {{endif}} + + {{if 'cuGraphBatchMemOpNodeGetParams' in found_functions}} + global __cuGraphBatchMemOpNodeGetParams + data["__cuGraphBatchMemOpNodeGetParams"] = __cuGraphBatchMemOpNodeGetParams + {{else}} + data["__cuGraphBatchMemOpNodeGetParams"] = 0 + {{endif}} + + {{if 'cuGraphBatchMemOpNodeSetParams' in found_functions}} + global __cuGraphBatchMemOpNodeSetParams + data["__cuGraphBatchMemOpNodeSetParams"] = __cuGraphBatchMemOpNodeSetParams + {{else}} + data["__cuGraphBatchMemOpNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphExecBatchMemOpNodeSetParams' in found_functions}} + global __cuGraphExecBatchMemOpNodeSetParams + data["__cuGraphExecBatchMemOpNodeSetParams"] = __cuGraphExecBatchMemOpNodeSetParams + {{else}} + data["__cuGraphExecBatchMemOpNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphAddMemAllocNode' in found_functions}} + global __cuGraphAddMemAllocNode + data["__cuGraphAddMemAllocNode"] = __cuGraphAddMemAllocNode + {{else}} + data["__cuGraphAddMemAllocNode"] = 0 + {{endif}} + + {{if 'cuGraphMemAllocNodeGetParams' in found_functions}} + global __cuGraphMemAllocNodeGetParams + data["__cuGraphMemAllocNodeGetParams"] = __cuGraphMemAllocNodeGetParams + {{else}} + data["__cuGraphMemAllocNodeGetParams"] = 0 + {{endif}} + + {{if 'cuGraphAddMemFreeNode' in found_functions}} + global __cuGraphAddMemFreeNode + data["__cuGraphAddMemFreeNode"] = __cuGraphAddMemFreeNode + {{else}} + data["__cuGraphAddMemFreeNode"] = 0 + {{endif}} + + {{if 'cuGraphMemFreeNodeGetParams' in found_functions}} + global __cuGraphMemFreeNodeGetParams + data["__cuGraphMemFreeNodeGetParams"] = __cuGraphMemFreeNodeGetParams + {{else}} + data["__cuGraphMemFreeNodeGetParams"] = 0 + {{endif}} + + {{if 'cuDeviceGraphMemTrim' in found_functions}} + global __cuDeviceGraphMemTrim + data["__cuDeviceGraphMemTrim"] = __cuDeviceGraphMemTrim + {{else}} + data["__cuDeviceGraphMemTrim"] = 0 + {{endif}} + + {{if 'cuDeviceGetGraphMemAttribute' in found_functions}} + global __cuDeviceGetGraphMemAttribute + data["__cuDeviceGetGraphMemAttribute"] = __cuDeviceGetGraphMemAttribute + {{else}} + data["__cuDeviceGetGraphMemAttribute"] = 0 + {{endif}} + + {{if 'cuDeviceSetGraphMemAttribute' in found_functions}} + global __cuDeviceSetGraphMemAttribute + data["__cuDeviceSetGraphMemAttribute"] = __cuDeviceSetGraphMemAttribute + {{else}} + data["__cuDeviceSetGraphMemAttribute"] = 0 + {{endif}} + + {{if 'cuGraphClone' in found_functions}} + global __cuGraphClone + data["__cuGraphClone"] = __cuGraphClone + {{else}} + data["__cuGraphClone"] = 0 + {{endif}} + + {{if 'cuGraphNodeFindInClone' in found_functions}} + global __cuGraphNodeFindInClone + data["__cuGraphNodeFindInClone"] = __cuGraphNodeFindInClone + {{else}} + data["__cuGraphNodeFindInClone"] = 0 + {{endif}} + + {{if 'cuGraphNodeGetType' in found_functions}} + global __cuGraphNodeGetType + data["__cuGraphNodeGetType"] = __cuGraphNodeGetType + {{else}} + data["__cuGraphNodeGetType"] = 0 + {{endif}} + + {{if 'cuGraphGetNodes' in found_functions}} + global __cuGraphGetNodes + data["__cuGraphGetNodes"] = __cuGraphGetNodes + {{else}} + data["__cuGraphGetNodes"] = 0 + {{endif}} + + {{if 'cuGraphGetRootNodes' in found_functions}} + global __cuGraphGetRootNodes + data["__cuGraphGetRootNodes"] = __cuGraphGetRootNodes + {{else}} + data["__cuGraphGetRootNodes"] = 0 + {{endif}} + + {{if 'cuGraphGetEdges' in found_functions}} + global __cuGraphGetEdges + data["__cuGraphGetEdges"] = __cuGraphGetEdges + {{else}} + data["__cuGraphGetEdges"] = 0 + {{endif}} + + {{if 'cuGraphGetEdges_v2' in found_functions}} + global __cuGraphGetEdges_v2 + data["__cuGraphGetEdges_v2"] = __cuGraphGetEdges_v2 + {{else}} + data["__cuGraphGetEdges_v2"] = 0 + {{endif}} + + {{if 'cuGraphNodeGetDependencies' in found_functions}} + global __cuGraphNodeGetDependencies + data["__cuGraphNodeGetDependencies"] = __cuGraphNodeGetDependencies + {{else}} + data["__cuGraphNodeGetDependencies"] = 0 + {{endif}} + + {{if 'cuGraphNodeGetDependencies_v2' in found_functions}} + global __cuGraphNodeGetDependencies_v2 + data["__cuGraphNodeGetDependencies_v2"] = __cuGraphNodeGetDependencies_v2 + {{else}} + data["__cuGraphNodeGetDependencies_v2"] = 0 + {{endif}} + + {{if 'cuGraphNodeGetDependentNodes' in found_functions}} + global __cuGraphNodeGetDependentNodes + data["__cuGraphNodeGetDependentNodes"] = __cuGraphNodeGetDependentNodes + {{else}} + data["__cuGraphNodeGetDependentNodes"] = 0 + {{endif}} + + {{if 'cuGraphNodeGetDependentNodes_v2' in found_functions}} + global __cuGraphNodeGetDependentNodes_v2 + data["__cuGraphNodeGetDependentNodes_v2"] = __cuGraphNodeGetDependentNodes_v2 + {{else}} + data["__cuGraphNodeGetDependentNodes_v2"] = 0 + {{endif}} + + {{if 'cuGraphAddDependencies' in found_functions}} + global __cuGraphAddDependencies + data["__cuGraphAddDependencies"] = __cuGraphAddDependencies + {{else}} + data["__cuGraphAddDependencies"] = 0 + {{endif}} + + {{if 'cuGraphAddDependencies_v2' in found_functions}} + global __cuGraphAddDependencies_v2 + data["__cuGraphAddDependencies_v2"] = __cuGraphAddDependencies_v2 + {{else}} + data["__cuGraphAddDependencies_v2"] = 0 + {{endif}} + + {{if 'cuGraphRemoveDependencies' in found_functions}} + global __cuGraphRemoveDependencies + data["__cuGraphRemoveDependencies"] = __cuGraphRemoveDependencies + {{else}} + data["__cuGraphRemoveDependencies"] = 0 + {{endif}} + + {{if 'cuGraphRemoveDependencies_v2' in found_functions}} + global __cuGraphRemoveDependencies_v2 + data["__cuGraphRemoveDependencies_v2"] = __cuGraphRemoveDependencies_v2 + {{else}} + data["__cuGraphRemoveDependencies_v2"] = 0 + {{endif}} + + {{if 'cuGraphDestroyNode' in found_functions}} + global __cuGraphDestroyNode + data["__cuGraphDestroyNode"] = __cuGraphDestroyNode + {{else}} + data["__cuGraphDestroyNode"] = 0 + {{endif}} + + {{if 'cuGraphInstantiateWithFlags' in found_functions}} + global __cuGraphInstantiateWithFlags + data["__cuGraphInstantiateWithFlags"] = __cuGraphInstantiateWithFlags + {{else}} + data["__cuGraphInstantiateWithFlags"] = 0 + {{endif}} + + {{if 'cuGraphInstantiateWithParams' in found_functions}} + global __cuGraphInstantiateWithParams + data["__cuGraphInstantiateWithParams"] = __cuGraphInstantiateWithParams + {{else}} + data["__cuGraphInstantiateWithParams"] = 0 + {{endif}} + + {{if 'cuGraphExecGetFlags' in found_functions}} + global __cuGraphExecGetFlags + data["__cuGraphExecGetFlags"] = __cuGraphExecGetFlags + {{else}} + data["__cuGraphExecGetFlags"] = 0 + {{endif}} + + {{if 'cuGraphExecKernelNodeSetParams_v2' in found_functions}} + global __cuGraphExecKernelNodeSetParams_v2 + data["__cuGraphExecKernelNodeSetParams_v2"] = __cuGraphExecKernelNodeSetParams_v2 + {{else}} + data["__cuGraphExecKernelNodeSetParams_v2"] = 0 + {{endif}} + + {{if 'cuGraphExecMemcpyNodeSetParams' in found_functions}} + global __cuGraphExecMemcpyNodeSetParams + data["__cuGraphExecMemcpyNodeSetParams"] = __cuGraphExecMemcpyNodeSetParams + {{else}} + data["__cuGraphExecMemcpyNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphExecMemsetNodeSetParams' in found_functions}} + global __cuGraphExecMemsetNodeSetParams + data["__cuGraphExecMemsetNodeSetParams"] = __cuGraphExecMemsetNodeSetParams + {{else}} + data["__cuGraphExecMemsetNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphExecHostNodeSetParams' in found_functions}} + global __cuGraphExecHostNodeSetParams + data["__cuGraphExecHostNodeSetParams"] = __cuGraphExecHostNodeSetParams + {{else}} + data["__cuGraphExecHostNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphExecChildGraphNodeSetParams' in found_functions}} + global __cuGraphExecChildGraphNodeSetParams + data["__cuGraphExecChildGraphNodeSetParams"] = __cuGraphExecChildGraphNodeSetParams + {{else}} + data["__cuGraphExecChildGraphNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphExecEventRecordNodeSetEvent' in found_functions}} + global __cuGraphExecEventRecordNodeSetEvent + data["__cuGraphExecEventRecordNodeSetEvent"] = __cuGraphExecEventRecordNodeSetEvent + {{else}} + data["__cuGraphExecEventRecordNodeSetEvent"] = 0 + {{endif}} + + {{if 'cuGraphExecEventWaitNodeSetEvent' in found_functions}} + global __cuGraphExecEventWaitNodeSetEvent + data["__cuGraphExecEventWaitNodeSetEvent"] = __cuGraphExecEventWaitNodeSetEvent + {{else}} + data["__cuGraphExecEventWaitNodeSetEvent"] = 0 + {{endif}} + + {{if 'cuGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} + global __cuGraphExecExternalSemaphoresSignalNodeSetParams + data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = __cuGraphExecExternalSemaphoresSignalNodeSetParams + {{else}} + data["__cuGraphExecExternalSemaphoresSignalNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} + global __cuGraphExecExternalSemaphoresWaitNodeSetParams + data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = __cuGraphExecExternalSemaphoresWaitNodeSetParams + {{else}} + data["__cuGraphExecExternalSemaphoresWaitNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphNodeSetEnabled' in found_functions}} + global __cuGraphNodeSetEnabled + data["__cuGraphNodeSetEnabled"] = __cuGraphNodeSetEnabled + {{else}} + data["__cuGraphNodeSetEnabled"] = 0 + {{endif}} + + {{if 'cuGraphNodeGetEnabled' in found_functions}} + global __cuGraphNodeGetEnabled + data["__cuGraphNodeGetEnabled"] = __cuGraphNodeGetEnabled + {{else}} + data["__cuGraphNodeGetEnabled"] = 0 + {{endif}} + + {{if 'cuGraphUpload' in found_functions}} + global __cuGraphUpload + data["__cuGraphUpload"] = __cuGraphUpload + {{else}} + data["__cuGraphUpload"] = 0 + {{endif}} + + {{if 'cuGraphLaunch' in found_functions}} + global __cuGraphLaunch + data["__cuGraphLaunch"] = __cuGraphLaunch + {{else}} + data["__cuGraphLaunch"] = 0 + {{endif}} + + {{if 'cuGraphExecDestroy' in found_functions}} + global __cuGraphExecDestroy + data["__cuGraphExecDestroy"] = __cuGraphExecDestroy + {{else}} + data["__cuGraphExecDestroy"] = 0 + {{endif}} + + {{if 'cuGraphDestroy' in found_functions}} + global __cuGraphDestroy + data["__cuGraphDestroy"] = __cuGraphDestroy + {{else}} + data["__cuGraphDestroy"] = 0 + {{endif}} + + {{if 'cuGraphExecUpdate_v2' in found_functions}} + global __cuGraphExecUpdate_v2 + data["__cuGraphExecUpdate_v2"] = __cuGraphExecUpdate_v2 + {{else}} + data["__cuGraphExecUpdate_v2"] = 0 + {{endif}} + + {{if 'cuGraphKernelNodeCopyAttributes' in found_functions}} + global __cuGraphKernelNodeCopyAttributes + data["__cuGraphKernelNodeCopyAttributes"] = __cuGraphKernelNodeCopyAttributes + {{else}} + data["__cuGraphKernelNodeCopyAttributes"] = 0 + {{endif}} + + {{if 'cuGraphKernelNodeGetAttribute' in found_functions}} + global __cuGraphKernelNodeGetAttribute + data["__cuGraphKernelNodeGetAttribute"] = __cuGraphKernelNodeGetAttribute + {{else}} + data["__cuGraphKernelNodeGetAttribute"] = 0 + {{endif}} + + {{if 'cuGraphKernelNodeSetAttribute' in found_functions}} + global __cuGraphKernelNodeSetAttribute + data["__cuGraphKernelNodeSetAttribute"] = __cuGraphKernelNodeSetAttribute + {{else}} + data["__cuGraphKernelNodeSetAttribute"] = 0 + {{endif}} + + {{if 'cuGraphDebugDotPrint' in found_functions}} + global __cuGraphDebugDotPrint + data["__cuGraphDebugDotPrint"] = __cuGraphDebugDotPrint + {{else}} + data["__cuGraphDebugDotPrint"] = 0 + {{endif}} + + {{if 'cuUserObjectCreate' in found_functions}} + global __cuUserObjectCreate + data["__cuUserObjectCreate"] = __cuUserObjectCreate + {{else}} + data["__cuUserObjectCreate"] = 0 + {{endif}} + + {{if 'cuUserObjectRetain' in found_functions}} + global __cuUserObjectRetain + data["__cuUserObjectRetain"] = __cuUserObjectRetain + {{else}} + data["__cuUserObjectRetain"] = 0 + {{endif}} + + {{if 'cuUserObjectRelease' in found_functions}} + global __cuUserObjectRelease + data["__cuUserObjectRelease"] = __cuUserObjectRelease + {{else}} + data["__cuUserObjectRelease"] = 0 + {{endif}} + + {{if 'cuGraphRetainUserObject' in found_functions}} + global __cuGraphRetainUserObject + data["__cuGraphRetainUserObject"] = __cuGraphRetainUserObject + {{else}} + data["__cuGraphRetainUserObject"] = 0 + {{endif}} + + {{if 'cuGraphReleaseUserObject' in found_functions}} + global __cuGraphReleaseUserObject + data["__cuGraphReleaseUserObject"] = __cuGraphReleaseUserObject + {{else}} + data["__cuGraphReleaseUserObject"] = 0 + {{endif}} + + {{if 'cuGraphAddNode' in found_functions}} + global __cuGraphAddNode + data["__cuGraphAddNode"] = __cuGraphAddNode + {{else}} + data["__cuGraphAddNode"] = 0 + {{endif}} + + {{if 'cuGraphAddNode_v2' in found_functions}} + global __cuGraphAddNode_v2 + data["__cuGraphAddNode_v2"] = __cuGraphAddNode_v2 + {{else}} + data["__cuGraphAddNode_v2"] = 0 + {{endif}} + + {{if 'cuGraphNodeSetParams' in found_functions}} + global __cuGraphNodeSetParams + data["__cuGraphNodeSetParams"] = __cuGraphNodeSetParams + {{else}} + data["__cuGraphNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphExecNodeSetParams' in found_functions}} + global __cuGraphExecNodeSetParams + data["__cuGraphExecNodeSetParams"] = __cuGraphExecNodeSetParams + {{else}} + data["__cuGraphExecNodeSetParams"] = 0 + {{endif}} + + {{if 'cuGraphConditionalHandleCreate' in found_functions}} + global __cuGraphConditionalHandleCreate + data["__cuGraphConditionalHandleCreate"] = __cuGraphConditionalHandleCreate + {{else}} + data["__cuGraphConditionalHandleCreate"] = 0 + {{endif}} + + {{if 'cuOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} + global __cuOccupancyMaxActiveBlocksPerMultiprocessor + data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = __cuOccupancyMaxActiveBlocksPerMultiprocessor + {{else}} + data["__cuOccupancyMaxActiveBlocksPerMultiprocessor"] = 0 + {{endif}} + + {{if 'cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} + global __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags + data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags + {{else}} + data["__cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"] = 0 + {{endif}} + + {{if 'cuOccupancyMaxPotentialBlockSize' in found_functions}} + global __cuOccupancyMaxPotentialBlockSize + data["__cuOccupancyMaxPotentialBlockSize"] = __cuOccupancyMaxPotentialBlockSize + {{else}} + data["__cuOccupancyMaxPotentialBlockSize"] = 0 + {{endif}} + + {{if 'cuOccupancyMaxPotentialBlockSizeWithFlags' in found_functions}} + global __cuOccupancyMaxPotentialBlockSizeWithFlags + data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = __cuOccupancyMaxPotentialBlockSizeWithFlags + {{else}} + data["__cuOccupancyMaxPotentialBlockSizeWithFlags"] = 0 + {{endif}} + + {{if 'cuOccupancyAvailableDynamicSMemPerBlock' in found_functions}} + global __cuOccupancyAvailableDynamicSMemPerBlock + data["__cuOccupancyAvailableDynamicSMemPerBlock"] = __cuOccupancyAvailableDynamicSMemPerBlock + {{else}} + data["__cuOccupancyAvailableDynamicSMemPerBlock"] = 0 + {{endif}} + + {{if 'cuOccupancyMaxPotentialClusterSize' in found_functions}} + global __cuOccupancyMaxPotentialClusterSize + data["__cuOccupancyMaxPotentialClusterSize"] = __cuOccupancyMaxPotentialClusterSize + {{else}} + data["__cuOccupancyMaxPotentialClusterSize"] = 0 + {{endif}} + + {{if 'cuOccupancyMaxActiveClusters' in found_functions}} + global __cuOccupancyMaxActiveClusters + data["__cuOccupancyMaxActiveClusters"] = __cuOccupancyMaxActiveClusters + {{else}} + data["__cuOccupancyMaxActiveClusters"] = 0 + {{endif}} + + {{if 'cuTexRefSetArray' in found_functions}} + global __cuTexRefSetArray + data["__cuTexRefSetArray"] = __cuTexRefSetArray + {{else}} + data["__cuTexRefSetArray"] = 0 + {{endif}} + + {{if 'cuTexRefSetMipmappedArray' in found_functions}} + global __cuTexRefSetMipmappedArray + data["__cuTexRefSetMipmappedArray"] = __cuTexRefSetMipmappedArray + {{else}} + data["__cuTexRefSetMipmappedArray"] = 0 + {{endif}} + + {{if 'cuTexRefSetAddress_v2' in found_functions}} + global __cuTexRefSetAddress_v2 + data["__cuTexRefSetAddress_v2"] = __cuTexRefSetAddress_v2 + {{else}} + data["__cuTexRefSetAddress_v2"] = 0 + {{endif}} + + {{if 'cuTexRefSetAddress2D_v3' in found_functions}} + global __cuTexRefSetAddress2D_v3 + data["__cuTexRefSetAddress2D_v3"] = __cuTexRefSetAddress2D_v3 + {{else}} + data["__cuTexRefSetAddress2D_v3"] = 0 + {{endif}} + + {{if 'cuTexRefSetFormat' in found_functions}} + global __cuTexRefSetFormat + data["__cuTexRefSetFormat"] = __cuTexRefSetFormat + {{else}} + data["__cuTexRefSetFormat"] = 0 + {{endif}} + + {{if 'cuTexRefSetAddressMode' in found_functions}} + global __cuTexRefSetAddressMode + data["__cuTexRefSetAddressMode"] = __cuTexRefSetAddressMode + {{else}} + data["__cuTexRefSetAddressMode"] = 0 + {{endif}} + + {{if 'cuTexRefSetFilterMode' in found_functions}} + global __cuTexRefSetFilterMode + data["__cuTexRefSetFilterMode"] = __cuTexRefSetFilterMode + {{else}} + data["__cuTexRefSetFilterMode"] = 0 + {{endif}} + + {{if 'cuTexRefSetMipmapFilterMode' in found_functions}} + global __cuTexRefSetMipmapFilterMode + data["__cuTexRefSetMipmapFilterMode"] = __cuTexRefSetMipmapFilterMode + {{else}} + data["__cuTexRefSetMipmapFilterMode"] = 0 + {{endif}} + + {{if 'cuTexRefSetMipmapLevelBias' in found_functions}} + global __cuTexRefSetMipmapLevelBias + data["__cuTexRefSetMipmapLevelBias"] = __cuTexRefSetMipmapLevelBias + {{else}} + data["__cuTexRefSetMipmapLevelBias"] = 0 + {{endif}} + + {{if 'cuTexRefSetMipmapLevelClamp' in found_functions}} + global __cuTexRefSetMipmapLevelClamp + data["__cuTexRefSetMipmapLevelClamp"] = __cuTexRefSetMipmapLevelClamp + {{else}} + data["__cuTexRefSetMipmapLevelClamp"] = 0 + {{endif}} + + {{if 'cuTexRefSetMaxAnisotropy' in found_functions}} + global __cuTexRefSetMaxAnisotropy + data["__cuTexRefSetMaxAnisotropy"] = __cuTexRefSetMaxAnisotropy + {{else}} + data["__cuTexRefSetMaxAnisotropy"] = 0 + {{endif}} + + {{if 'cuTexRefSetBorderColor' in found_functions}} + global __cuTexRefSetBorderColor + data["__cuTexRefSetBorderColor"] = __cuTexRefSetBorderColor + {{else}} + data["__cuTexRefSetBorderColor"] = 0 + {{endif}} + + {{if 'cuTexRefSetFlags' in found_functions}} + global __cuTexRefSetFlags + data["__cuTexRefSetFlags"] = __cuTexRefSetFlags + {{else}} + data["__cuTexRefSetFlags"] = 0 + {{endif}} + + {{if 'cuTexRefGetAddress_v2' in found_functions}} + global __cuTexRefGetAddress_v2 + data["__cuTexRefGetAddress_v2"] = __cuTexRefGetAddress_v2 + {{else}} + data["__cuTexRefGetAddress_v2"] = 0 + {{endif}} + + {{if 'cuTexRefGetArray' in found_functions}} + global __cuTexRefGetArray + data["__cuTexRefGetArray"] = __cuTexRefGetArray + {{else}} + data["__cuTexRefGetArray"] = 0 + {{endif}} + + {{if 'cuTexRefGetMipmappedArray' in found_functions}} + global __cuTexRefGetMipmappedArray + data["__cuTexRefGetMipmappedArray"] = __cuTexRefGetMipmappedArray + {{else}} + data["__cuTexRefGetMipmappedArray"] = 0 + {{endif}} + + {{if 'cuTexRefGetAddressMode' in found_functions}} + global __cuTexRefGetAddressMode + data["__cuTexRefGetAddressMode"] = __cuTexRefGetAddressMode + {{else}} + data["__cuTexRefGetAddressMode"] = 0 + {{endif}} + + {{if 'cuTexRefGetFilterMode' in found_functions}} + global __cuTexRefGetFilterMode + data["__cuTexRefGetFilterMode"] = __cuTexRefGetFilterMode + {{else}} + data["__cuTexRefGetFilterMode"] = 0 + {{endif}} + + {{if 'cuTexRefGetFormat' in found_functions}} + global __cuTexRefGetFormat + data["__cuTexRefGetFormat"] = __cuTexRefGetFormat + {{else}} + data["__cuTexRefGetFormat"] = 0 + {{endif}} + + {{if 'cuTexRefGetMipmapFilterMode' in found_functions}} + global __cuTexRefGetMipmapFilterMode + data["__cuTexRefGetMipmapFilterMode"] = __cuTexRefGetMipmapFilterMode + {{else}} + data["__cuTexRefGetMipmapFilterMode"] = 0 + {{endif}} + + {{if 'cuTexRefGetMipmapLevelBias' in found_functions}} + global __cuTexRefGetMipmapLevelBias + data["__cuTexRefGetMipmapLevelBias"] = __cuTexRefGetMipmapLevelBias + {{else}} + data["__cuTexRefGetMipmapLevelBias"] = 0 + {{endif}} + + {{if 'cuTexRefGetMipmapLevelClamp' in found_functions}} + global __cuTexRefGetMipmapLevelClamp + data["__cuTexRefGetMipmapLevelClamp"] = __cuTexRefGetMipmapLevelClamp + {{else}} + data["__cuTexRefGetMipmapLevelClamp"] = 0 + {{endif}} + + {{if 'cuTexRefGetMaxAnisotropy' in found_functions}} + global __cuTexRefGetMaxAnisotropy + data["__cuTexRefGetMaxAnisotropy"] = __cuTexRefGetMaxAnisotropy + {{else}} + data["__cuTexRefGetMaxAnisotropy"] = 0 + {{endif}} + + {{if 'cuTexRefGetBorderColor' in found_functions}} + global __cuTexRefGetBorderColor + data["__cuTexRefGetBorderColor"] = __cuTexRefGetBorderColor + {{else}} + data["__cuTexRefGetBorderColor"] = 0 + {{endif}} + + {{if 'cuTexRefGetFlags' in found_functions}} + global __cuTexRefGetFlags + data["__cuTexRefGetFlags"] = __cuTexRefGetFlags + {{else}} + data["__cuTexRefGetFlags"] = 0 + {{endif}} + + {{if 'cuTexRefCreate' in found_functions}} + global __cuTexRefCreate + data["__cuTexRefCreate"] = __cuTexRefCreate + {{else}} + data["__cuTexRefCreate"] = 0 + {{endif}} + + {{if 'cuTexRefDestroy' in found_functions}} + global __cuTexRefDestroy + data["__cuTexRefDestroy"] = __cuTexRefDestroy + {{else}} + data["__cuTexRefDestroy"] = 0 + {{endif}} + + {{if 'cuSurfRefSetArray' in found_functions}} + global __cuSurfRefSetArray + data["__cuSurfRefSetArray"] = __cuSurfRefSetArray + {{else}} + data["__cuSurfRefSetArray"] = 0 + {{endif}} + + {{if 'cuSurfRefGetArray' in found_functions}} + global __cuSurfRefGetArray + data["__cuSurfRefGetArray"] = __cuSurfRefGetArray + {{else}} + data["__cuSurfRefGetArray"] = 0 + {{endif}} + + {{if 'cuTexObjectCreate' in found_functions}} + global __cuTexObjectCreate + data["__cuTexObjectCreate"] = __cuTexObjectCreate + {{else}} + data["__cuTexObjectCreate"] = 0 + {{endif}} + + {{if 'cuTexObjectDestroy' in found_functions}} + global __cuTexObjectDestroy + data["__cuTexObjectDestroy"] = __cuTexObjectDestroy + {{else}} + data["__cuTexObjectDestroy"] = 0 + {{endif}} + + {{if 'cuTexObjectGetResourceDesc' in found_functions}} + global __cuTexObjectGetResourceDesc + data["__cuTexObjectGetResourceDesc"] = __cuTexObjectGetResourceDesc + {{else}} + data["__cuTexObjectGetResourceDesc"] = 0 + {{endif}} + + {{if 'cuTexObjectGetTextureDesc' in found_functions}} + global __cuTexObjectGetTextureDesc + data["__cuTexObjectGetTextureDesc"] = __cuTexObjectGetTextureDesc + {{else}} + data["__cuTexObjectGetTextureDesc"] = 0 + {{endif}} + + {{if 'cuTexObjectGetResourceViewDesc' in found_functions}} + global __cuTexObjectGetResourceViewDesc + data["__cuTexObjectGetResourceViewDesc"] = __cuTexObjectGetResourceViewDesc + {{else}} + data["__cuTexObjectGetResourceViewDesc"] = 0 + {{endif}} + + {{if 'cuSurfObjectCreate' in found_functions}} + global __cuSurfObjectCreate + data["__cuSurfObjectCreate"] = __cuSurfObjectCreate + {{else}} + data["__cuSurfObjectCreate"] = 0 + {{endif}} + + {{if 'cuSurfObjectDestroy' in found_functions}} + global __cuSurfObjectDestroy + data["__cuSurfObjectDestroy"] = __cuSurfObjectDestroy + {{else}} + data["__cuSurfObjectDestroy"] = 0 + {{endif}} + + {{if 'cuSurfObjectGetResourceDesc' in found_functions}} + global __cuSurfObjectGetResourceDesc + data["__cuSurfObjectGetResourceDesc"] = __cuSurfObjectGetResourceDesc + {{else}} + data["__cuSurfObjectGetResourceDesc"] = 0 + {{endif}} + + {{if 'cuTensorMapEncodeTiled' in found_functions}} + global __cuTensorMapEncodeTiled + data["__cuTensorMapEncodeTiled"] = __cuTensorMapEncodeTiled + {{else}} + data["__cuTensorMapEncodeTiled"] = 0 + {{endif}} + + {{if 'cuTensorMapEncodeIm2col' in found_functions}} + global __cuTensorMapEncodeIm2col + data["__cuTensorMapEncodeIm2col"] = __cuTensorMapEncodeIm2col + {{else}} + data["__cuTensorMapEncodeIm2col"] = 0 + {{endif}} + + {{if 'cuTensorMapEncodeIm2colWide' in found_functions}} + global __cuTensorMapEncodeIm2colWide + data["__cuTensorMapEncodeIm2colWide"] = __cuTensorMapEncodeIm2colWide + {{else}} + data["__cuTensorMapEncodeIm2colWide"] = 0 + {{endif}} + + {{if 'cuTensorMapReplaceAddress' in found_functions}} + global __cuTensorMapReplaceAddress + data["__cuTensorMapReplaceAddress"] = __cuTensorMapReplaceAddress + {{else}} + data["__cuTensorMapReplaceAddress"] = 0 + {{endif}} + + {{if 'cuDeviceCanAccessPeer' in found_functions}} + global __cuDeviceCanAccessPeer + data["__cuDeviceCanAccessPeer"] = __cuDeviceCanAccessPeer + {{else}} + data["__cuDeviceCanAccessPeer"] = 0 + {{endif}} + + {{if 'cuCtxEnablePeerAccess' in found_functions}} + global __cuCtxEnablePeerAccess + data["__cuCtxEnablePeerAccess"] = __cuCtxEnablePeerAccess + {{else}} + data["__cuCtxEnablePeerAccess"] = 0 + {{endif}} + + {{if 'cuCtxDisablePeerAccess' in found_functions}} + global __cuCtxDisablePeerAccess + data["__cuCtxDisablePeerAccess"] = __cuCtxDisablePeerAccess + {{else}} + data["__cuCtxDisablePeerAccess"] = 0 + {{endif}} + + {{if 'cuDeviceGetP2PAttribute' in found_functions}} + global __cuDeviceGetP2PAttribute + data["__cuDeviceGetP2PAttribute"] = __cuDeviceGetP2PAttribute + {{else}} + data["__cuDeviceGetP2PAttribute"] = 0 + {{endif}} + + {{if 'cuGraphicsUnregisterResource' in found_functions}} + global __cuGraphicsUnregisterResource + data["__cuGraphicsUnregisterResource"] = __cuGraphicsUnregisterResource + {{else}} + data["__cuGraphicsUnregisterResource"] = 0 + {{endif}} + + {{if 'cuGraphicsSubResourceGetMappedArray' in found_functions}} + global __cuGraphicsSubResourceGetMappedArray + data["__cuGraphicsSubResourceGetMappedArray"] = __cuGraphicsSubResourceGetMappedArray + {{else}} + data["__cuGraphicsSubResourceGetMappedArray"] = 0 + {{endif}} + + {{if 'cuGraphicsResourceGetMappedMipmappedArray' in found_functions}} + global __cuGraphicsResourceGetMappedMipmappedArray + data["__cuGraphicsResourceGetMappedMipmappedArray"] = __cuGraphicsResourceGetMappedMipmappedArray + {{else}} + data["__cuGraphicsResourceGetMappedMipmappedArray"] = 0 + {{endif}} + + {{if 'cuGraphicsResourceGetMappedPointer_v2' in found_functions}} + global __cuGraphicsResourceGetMappedPointer_v2 + data["__cuGraphicsResourceGetMappedPointer_v2"] = __cuGraphicsResourceGetMappedPointer_v2 + {{else}} + data["__cuGraphicsResourceGetMappedPointer_v2"] = 0 + {{endif}} + + {{if 'cuGraphicsResourceSetMapFlags_v2' in found_functions}} + global __cuGraphicsResourceSetMapFlags_v2 + data["__cuGraphicsResourceSetMapFlags_v2"] = __cuGraphicsResourceSetMapFlags_v2 + {{else}} + data["__cuGraphicsResourceSetMapFlags_v2"] = 0 + {{endif}} + + {{if 'cuGraphicsMapResources' in found_functions}} + global __cuGraphicsMapResources + data["__cuGraphicsMapResources"] = __cuGraphicsMapResources + {{else}} + data["__cuGraphicsMapResources"] = 0 + {{endif}} + + {{if 'cuGraphicsUnmapResources' in found_functions}} + global __cuGraphicsUnmapResources + data["__cuGraphicsUnmapResources"] = __cuGraphicsUnmapResources + {{else}} + data["__cuGraphicsUnmapResources"] = 0 + {{endif}} + + {{if 'cuGetProcAddress_v2' in found_functions}} + global __cuGetProcAddress_v2 + data["__cuGetProcAddress_v2"] = __cuGetProcAddress_v2 + {{else}} + data["__cuGetProcAddress_v2"] = 0 + {{endif}} + + {{if 'cuCoredumpGetAttribute' in found_functions}} + global __cuCoredumpGetAttribute + data["__cuCoredumpGetAttribute"] = __cuCoredumpGetAttribute + {{else}} + data["__cuCoredumpGetAttribute"] = 0 + {{endif}} + + {{if 'cuCoredumpGetAttributeGlobal' in found_functions}} + global __cuCoredumpGetAttributeGlobal + data["__cuCoredumpGetAttributeGlobal"] = __cuCoredumpGetAttributeGlobal + {{else}} + data["__cuCoredumpGetAttributeGlobal"] = 0 + {{endif}} + + {{if 'cuCoredumpSetAttribute' in found_functions}} + global __cuCoredumpSetAttribute + data["__cuCoredumpSetAttribute"] = __cuCoredumpSetAttribute + {{else}} + data["__cuCoredumpSetAttribute"] = 0 + {{endif}} + + {{if 'cuCoredumpSetAttributeGlobal' in found_functions}} + global __cuCoredumpSetAttributeGlobal + data["__cuCoredumpSetAttributeGlobal"] = __cuCoredumpSetAttributeGlobal + {{else}} + data["__cuCoredumpSetAttributeGlobal"] = 0 + {{endif}} + + {{if 'cuGetExportTable' in found_functions}} + global __cuGetExportTable + data["__cuGetExportTable"] = __cuGetExportTable + {{else}} + data["__cuGetExportTable"] = 0 + {{endif}} + + {{if 'cuGreenCtxCreate' in found_functions}} + global __cuGreenCtxCreate + data["__cuGreenCtxCreate"] = __cuGreenCtxCreate + {{else}} + data["__cuGreenCtxCreate"] = 0 + {{endif}} + + {{if 'cuGreenCtxDestroy' in found_functions}} + global __cuGreenCtxDestroy + data["__cuGreenCtxDestroy"] = __cuGreenCtxDestroy + {{else}} + data["__cuGreenCtxDestroy"] = 0 + {{endif}} + + {{if 'cuCtxFromGreenCtx' in found_functions}} + global __cuCtxFromGreenCtx + data["__cuCtxFromGreenCtx"] = __cuCtxFromGreenCtx + {{else}} + data["__cuCtxFromGreenCtx"] = 0 + {{endif}} + + {{if 'cuDeviceGetDevResource' in found_functions}} + global __cuDeviceGetDevResource + data["__cuDeviceGetDevResource"] = __cuDeviceGetDevResource + {{else}} + data["__cuDeviceGetDevResource"] = 0 + {{endif}} + + {{if 'cuCtxGetDevResource' in found_functions}} + global __cuCtxGetDevResource + data["__cuCtxGetDevResource"] = __cuCtxGetDevResource + {{else}} + data["__cuCtxGetDevResource"] = 0 + {{endif}} + + {{if 'cuGreenCtxGetDevResource' in found_functions}} + global __cuGreenCtxGetDevResource + data["__cuGreenCtxGetDevResource"] = __cuGreenCtxGetDevResource + {{else}} + data["__cuGreenCtxGetDevResource"] = 0 + {{endif}} + + {{if 'cuDevSmResourceSplitByCount' in found_functions}} + global __cuDevSmResourceSplitByCount + data["__cuDevSmResourceSplitByCount"] = __cuDevSmResourceSplitByCount + {{else}} + data["__cuDevSmResourceSplitByCount"] = 0 + {{endif}} + + {{if 'cuDevResourceGenerateDesc' in found_functions}} + global __cuDevResourceGenerateDesc + data["__cuDevResourceGenerateDesc"] = __cuDevResourceGenerateDesc + {{else}} + data["__cuDevResourceGenerateDesc"] = 0 + {{endif}} + + {{if 'cuGreenCtxRecordEvent' in found_functions}} + global __cuGreenCtxRecordEvent + data["__cuGreenCtxRecordEvent"] = __cuGreenCtxRecordEvent + {{else}} + data["__cuGreenCtxRecordEvent"] = 0 + {{endif}} + + {{if 'cuGreenCtxWaitEvent' in found_functions}} + global __cuGreenCtxWaitEvent + data["__cuGreenCtxWaitEvent"] = __cuGreenCtxWaitEvent + {{else}} + data["__cuGreenCtxWaitEvent"] = 0 + {{endif}} + + {{if 'cuStreamGetGreenCtx' in found_functions}} + global __cuStreamGetGreenCtx + data["__cuStreamGetGreenCtx"] = __cuStreamGetGreenCtx + {{else}} + data["__cuStreamGetGreenCtx"] = 0 + {{endif}} + + {{if 'cuGreenCtxStreamCreate' in found_functions}} + global __cuGreenCtxStreamCreate + data["__cuGreenCtxStreamCreate"] = __cuGreenCtxStreamCreate + {{else}} + data["__cuGreenCtxStreamCreate"] = 0 + {{endif}} + + {{if 'cuLogsRegisterCallback' in found_functions}} + global __cuLogsRegisterCallback + data["__cuLogsRegisterCallback"] = __cuLogsRegisterCallback + {{else}} + data["__cuLogsRegisterCallback"] = 0 + {{endif}} + + {{if 'cuLogsUnregisterCallback' in found_functions}} + global __cuLogsUnregisterCallback + data["__cuLogsUnregisterCallback"] = __cuLogsUnregisterCallback + {{else}} + data["__cuLogsUnregisterCallback"] = 0 + {{endif}} + + {{if 'cuLogsCurrent' in found_functions}} + global __cuLogsCurrent + data["__cuLogsCurrent"] = __cuLogsCurrent + {{else}} + data["__cuLogsCurrent"] = 0 + {{endif}} + + {{if 'cuLogsDumpToFile' in found_functions}} + global __cuLogsDumpToFile + data["__cuLogsDumpToFile"] = __cuLogsDumpToFile + {{else}} + data["__cuLogsDumpToFile"] = 0 + {{endif}} + + {{if 'cuLogsDumpToMemory' in found_functions}} + global __cuLogsDumpToMemory + data["__cuLogsDumpToMemory"] = __cuLogsDumpToMemory + {{else}} + data["__cuLogsDumpToMemory"] = 0 + {{endif}} + + {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} + global __cuCheckpointProcessGetRestoreThreadId + data["__cuCheckpointProcessGetRestoreThreadId"] = __cuCheckpointProcessGetRestoreThreadId + {{else}} + data["__cuCheckpointProcessGetRestoreThreadId"] = 0 + {{endif}} + + {{if 'cuCheckpointProcessGetState' in found_functions}} + global __cuCheckpointProcessGetState + data["__cuCheckpointProcessGetState"] = __cuCheckpointProcessGetState + {{else}} + data["__cuCheckpointProcessGetState"] = 0 + {{endif}} + + {{if 'cuCheckpointProcessLock' in found_functions}} + global __cuCheckpointProcessLock + data["__cuCheckpointProcessLock"] = __cuCheckpointProcessLock + {{else}} + data["__cuCheckpointProcessLock"] = 0 + {{endif}} + + {{if 'cuCheckpointProcessCheckpoint' in found_functions}} + global __cuCheckpointProcessCheckpoint + data["__cuCheckpointProcessCheckpoint"] = __cuCheckpointProcessCheckpoint + {{else}} + data["__cuCheckpointProcessCheckpoint"] = 0 + {{endif}} + + {{if 'cuCheckpointProcessRestore' in found_functions}} + global __cuCheckpointProcessRestore + data["__cuCheckpointProcessRestore"] = __cuCheckpointProcessRestore + {{else}} + data["__cuCheckpointProcessRestore"] = 0 + {{endif}} + + {{if 'cuCheckpointProcessUnlock' in found_functions}} + global __cuCheckpointProcessUnlock + data["__cuCheckpointProcessUnlock"] = __cuCheckpointProcessUnlock + {{else}} + data["__cuCheckpointProcessUnlock"] = 0 + {{endif}} + + {{if 'cuProfilerStart' in found_functions}} + global __cuProfilerStart + data["__cuProfilerStart"] = __cuProfilerStart + {{else}} + data["__cuProfilerStart"] = 0 + {{endif}} + + {{if 'cuProfilerStop' in found_functions}} + global __cuProfilerStop + data["__cuProfilerStop"] = __cuProfilerStop + {{else}} + data["__cuProfilerStop"] = 0 + {{endif}} + + {{if True}} + global __cuGraphicsEGLRegisterImage + data["__cuGraphicsEGLRegisterImage"] = __cuGraphicsEGLRegisterImage + {{else}} + data["__cuGraphicsEGLRegisterImage"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamConsumerConnect + data["__cuEGLStreamConsumerConnect"] = __cuEGLStreamConsumerConnect + {{else}} + data["__cuEGLStreamConsumerConnect"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamConsumerConnectWithFlags + data["__cuEGLStreamConsumerConnectWithFlags"] = __cuEGLStreamConsumerConnectWithFlags + {{else}} + data["__cuEGLStreamConsumerConnectWithFlags"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamConsumerDisconnect + data["__cuEGLStreamConsumerDisconnect"] = __cuEGLStreamConsumerDisconnect + {{else}} + data["__cuEGLStreamConsumerDisconnect"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamConsumerAcquireFrame + data["__cuEGLStreamConsumerAcquireFrame"] = __cuEGLStreamConsumerAcquireFrame + {{else}} + data["__cuEGLStreamConsumerAcquireFrame"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamConsumerReleaseFrame + data["__cuEGLStreamConsumerReleaseFrame"] = __cuEGLStreamConsumerReleaseFrame + {{else}} + data["__cuEGLStreamConsumerReleaseFrame"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamProducerConnect + data["__cuEGLStreamProducerConnect"] = __cuEGLStreamProducerConnect + {{else}} + data["__cuEGLStreamProducerConnect"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamProducerDisconnect + data["__cuEGLStreamProducerDisconnect"] = __cuEGLStreamProducerDisconnect + {{else}} + data["__cuEGLStreamProducerDisconnect"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamProducerPresentFrame + data["__cuEGLStreamProducerPresentFrame"] = __cuEGLStreamProducerPresentFrame + {{else}} + data["__cuEGLStreamProducerPresentFrame"] = 0 + {{endif}} + + {{if True}} + global __cuEGLStreamProducerReturnFrame + data["__cuEGLStreamProducerReturnFrame"] = __cuEGLStreamProducerReturnFrame + {{else}} + data["__cuEGLStreamProducerReturnFrame"] = 0 + {{endif}} + + {{if True}} + global __cuGraphicsResourceGetMappedEglFrame + data["__cuGraphicsResourceGetMappedEglFrame"] = __cuGraphicsResourceGetMappedEglFrame + {{else}} + data["__cuGraphicsResourceGetMappedEglFrame"] = 0 + {{endif}} + + {{if True}} + global __cuEventCreateFromEGLSync + data["__cuEventCreateFromEGLSync"] = __cuEventCreateFromEGLSync + {{else}} + data["__cuEventCreateFromEGLSync"] = 0 + {{endif}} + + {{if True}} + global __cuGraphicsGLRegisterBuffer + data["__cuGraphicsGLRegisterBuffer"] = __cuGraphicsGLRegisterBuffer + {{else}} + data["__cuGraphicsGLRegisterBuffer"] = 0 + {{endif}} + + {{if True}} + global __cuGraphicsGLRegisterImage + data["__cuGraphicsGLRegisterImage"] = __cuGraphicsGLRegisterImage + {{else}} + data["__cuGraphicsGLRegisterImage"] = 0 + {{endif}} + + {{if True}} + global __cuGLGetDevices_v2 + data["__cuGLGetDevices_v2"] = __cuGLGetDevices_v2 + {{else}} + data["__cuGLGetDevices_v2"] = 0 + {{endif}} + + {{if True}} + global __cuVDPAUGetDevice + data["__cuVDPAUGetDevice"] = __cuVDPAUGetDevice + {{else}} + data["__cuVDPAUGetDevice"] = 0 + {{endif}} + + {{if True}} + global __cuVDPAUCtxCreate_v2 + data["__cuVDPAUCtxCreate_v2"] = __cuVDPAUCtxCreate_v2 + {{else}} + data["__cuVDPAUCtxCreate_v2"] = 0 + {{endif}} + + {{if True}} + global __cuGraphicsVDPAURegisterVideoSurface + data["__cuGraphicsVDPAURegisterVideoSurface"] = __cuGraphicsVDPAURegisterVideoSurface + {{else}} + data["__cuGraphicsVDPAURegisterVideoSurface"] = 0 + {{endif}} + + {{if True}} + global __cuGraphicsVDPAURegisterOutputSurface + data["__cuGraphicsVDPAURegisterOutputSurface"] = __cuGraphicsVDPAURegisterOutputSurface + {{else}} + data["__cuGraphicsVDPAURegisterOutputSurface"] = 0 + {{endif}} + + func_ptrs = data + return data + +cpdef _inspect_function_pointer(str name): + global func_ptrs + if func_ptrs is None: + func_ptrs = _inspect_function_pointers() + return func_ptrs[name] diff --git a/cuda_bindings/cuda/bindings/_bindings/cynvrtc.pxd.in b/cuda_bindings/cuda/bindings/_bindings/cynvrtc.pxd.in index 1e69d8f32..b45bdde3c 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cynvrtc.pxd.in +++ b/cuda_bindings/cuda/bindings/_bindings/cynvrtc.pxd.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. from cuda.bindings.cynvrtc cimport * {{if 'nvrtcGetErrorString' in found_functions}} diff --git a/cuda_bindings/cuda/bindings/_bindings/cynvrtc.pyx.in b/cuda_bindings/cuda/bindings/_bindings/cynvrtc.pyx.in index caf36d40e..d102901cf 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cynvrtc.pyx.in +++ b/cuda_bindings/cuda/bindings/_bindings/cynvrtc.pyx.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. {{if 'Windows' == platform.system()}} import os import site @@ -17,6 +17,8 @@ from pywintypes import error cimport cuda.bindings._lib.dlfcn as dlfcn {{endif}} +from libc.stdint cimport intptr_t + cdef bint __cuPythonInit = False {{if 'nvrtcGetErrorString' in found_functions}}cdef void *__nvrtcGetErrorString = NULL{{endif}} {{if 'nvrtcVersion' in found_functions}}cdef void *__nvrtcVersion = NULL{{endif}} @@ -707,3 +709,204 @@ cdef nvrtcResult _nvrtcSetFlowCallback(nvrtcProgram prog, void* callback, void* err = ( __nvrtcSetFlowCallback)(prog, callback, payload) return err {{endif}} + +cdef dict func_ptrs = None + +cpdef dict _inspect_function_pointers(): + global func_ptrs + if func_ptrs is not None: + return func_ptrs + + cuPythonInit() + cdef dict data = {} + + {{if 'nvrtcGetErrorString' in found_functions}} + global __nvrtcGetErrorString + data["__nvrtcGetErrorString"] = __nvrtcGetErrorString + {{else}} + data["__nvrtcGetErrorString"] = 0 + {{endif}} + + {{if 'nvrtcVersion' in found_functions}} + global __nvrtcVersion + data["__nvrtcVersion"] = __nvrtcVersion + {{else}} + data["__nvrtcVersion"] = 0 + {{endif}} + + {{if 'nvrtcGetNumSupportedArchs' in found_functions}} + global __nvrtcGetNumSupportedArchs + data["__nvrtcGetNumSupportedArchs"] = __nvrtcGetNumSupportedArchs + {{else}} + data["__nvrtcGetNumSupportedArchs"] = 0 + {{endif}} + + {{if 'nvrtcGetSupportedArchs' in found_functions}} + global __nvrtcGetSupportedArchs + data["__nvrtcGetSupportedArchs"] = __nvrtcGetSupportedArchs + {{else}} + data["__nvrtcGetSupportedArchs"] = 0 + {{endif}} + + {{if 'nvrtcCreateProgram' in found_functions}} + global __nvrtcCreateProgram + data["__nvrtcCreateProgram"] = __nvrtcCreateProgram + {{else}} + data["__nvrtcCreateProgram"] = 0 + {{endif}} + + {{if 'nvrtcDestroyProgram' in found_functions}} + global __nvrtcDestroyProgram + data["__nvrtcDestroyProgram"] = __nvrtcDestroyProgram + {{else}} + data["__nvrtcDestroyProgram"] = 0 + {{endif}} + + {{if 'nvrtcCompileProgram' in found_functions}} + global __nvrtcCompileProgram + data["__nvrtcCompileProgram"] = __nvrtcCompileProgram + {{else}} + data["__nvrtcCompileProgram"] = 0 + {{endif}} + + {{if 'nvrtcGetPTXSize' in found_functions}} + global __nvrtcGetPTXSize + data["__nvrtcGetPTXSize"] = __nvrtcGetPTXSize + {{else}} + data["__nvrtcGetPTXSize"] = 0 + {{endif}} + + {{if 'nvrtcGetPTX' in found_functions}} + global __nvrtcGetPTX + data["__nvrtcGetPTX"] = __nvrtcGetPTX + {{else}} + data["__nvrtcGetPTX"] = 0 + {{endif}} + + {{if 'nvrtcGetCUBINSize' in found_functions}} + global __nvrtcGetCUBINSize + data["__nvrtcGetCUBINSize"] = __nvrtcGetCUBINSize + {{else}} + data["__nvrtcGetCUBINSize"] = 0 + {{endif}} + + {{if 'nvrtcGetCUBIN' in found_functions}} + global __nvrtcGetCUBIN + data["__nvrtcGetCUBIN"] = __nvrtcGetCUBIN + {{else}} + data["__nvrtcGetCUBIN"] = 0 + {{endif}} + + {{if 'nvrtcGetNVVMSize' in found_functions}} + global __nvrtcGetNVVMSize + data["__nvrtcGetNVVMSize"] = __nvrtcGetNVVMSize + {{else}} + data["__nvrtcGetNVVMSize"] = 0 + {{endif}} + + {{if 'nvrtcGetNVVM' in found_functions}} + global __nvrtcGetNVVM + data["__nvrtcGetNVVM"] = __nvrtcGetNVVM + {{else}} + data["__nvrtcGetNVVM"] = 0 + {{endif}} + + {{if 'nvrtcGetLTOIRSize' in found_functions}} + global __nvrtcGetLTOIRSize + data["__nvrtcGetLTOIRSize"] = __nvrtcGetLTOIRSize + {{else}} + data["__nvrtcGetLTOIRSize"] = 0 + {{endif}} + + {{if 'nvrtcGetLTOIR' in found_functions}} + global __nvrtcGetLTOIR + data["__nvrtcGetLTOIR"] = __nvrtcGetLTOIR + {{else}} + data["__nvrtcGetLTOIR"] = 0 + {{endif}} + + {{if 'nvrtcGetOptiXIRSize' in found_functions}} + global __nvrtcGetOptiXIRSize + data["__nvrtcGetOptiXIRSize"] = __nvrtcGetOptiXIRSize + {{else}} + data["__nvrtcGetOptiXIRSize"] = 0 + {{endif}} + + {{if 'nvrtcGetOptiXIR' in found_functions}} + global __nvrtcGetOptiXIR + data["__nvrtcGetOptiXIR"] = __nvrtcGetOptiXIR + {{else}} + data["__nvrtcGetOptiXIR"] = 0 + {{endif}} + + {{if 'nvrtcGetProgramLogSize' in found_functions}} + global __nvrtcGetProgramLogSize + data["__nvrtcGetProgramLogSize"] = __nvrtcGetProgramLogSize + {{else}} + data["__nvrtcGetProgramLogSize"] = 0 + {{endif}} + + {{if 'nvrtcGetProgramLog' in found_functions}} + global __nvrtcGetProgramLog + data["__nvrtcGetProgramLog"] = __nvrtcGetProgramLog + {{else}} + data["__nvrtcGetProgramLog"] = 0 + {{endif}} + + {{if 'nvrtcAddNameExpression' in found_functions}} + global __nvrtcAddNameExpression + data["__nvrtcAddNameExpression"] = __nvrtcAddNameExpression + {{else}} + data["__nvrtcAddNameExpression"] = 0 + {{endif}} + + {{if 'nvrtcGetLoweredName' in found_functions}} + global __nvrtcGetLoweredName + data["__nvrtcGetLoweredName"] = __nvrtcGetLoweredName + {{else}} + data["__nvrtcGetLoweredName"] = 0 + {{endif}} + + {{if 'nvrtcGetPCHHeapSize' in found_functions}} + global __nvrtcGetPCHHeapSize + data["__nvrtcGetPCHHeapSize"] = __nvrtcGetPCHHeapSize + {{else}} + data["__nvrtcGetPCHHeapSize"] = 0 + {{endif}} + + {{if 'nvrtcSetPCHHeapSize' in found_functions}} + global __nvrtcSetPCHHeapSize + data["__nvrtcSetPCHHeapSize"] = __nvrtcSetPCHHeapSize + {{else}} + data["__nvrtcSetPCHHeapSize"] = 0 + {{endif}} + + {{if 'nvrtcGetPCHCreateStatus' in found_functions}} + global __nvrtcGetPCHCreateStatus + data["__nvrtcGetPCHCreateStatus"] = __nvrtcGetPCHCreateStatus + {{else}} + data["__nvrtcGetPCHCreateStatus"] = 0 + {{endif}} + + {{if 'nvrtcGetPCHHeapSizeRequired' in found_functions}} + global __nvrtcGetPCHHeapSizeRequired + data["__nvrtcGetPCHHeapSizeRequired"] = __nvrtcGetPCHHeapSizeRequired + {{else}} + data["__nvrtcGetPCHHeapSizeRequired"] = 0 + {{endif}} + + {{if 'nvrtcSetFlowCallback' in found_functions}} + global __nvrtcSetFlowCallback + data["__nvrtcSetFlowCallback"] = __nvrtcSetFlowCallback + {{else}} + data["__nvrtcSetFlowCallback"] = 0 + {{endif}} + + func_ptrs = data + return data + +cpdef _inspect_function_pointer(str name): + global func_ptrs + if func_ptrs is None: + func_ptrs = _inspect_function_pointers() + return func_ptrs[name] diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in index cfddb0863..aef8a71b2 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxd.in @@ -6,1465 +6,1465 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. -cimport cuda.bindings.cyruntime as cyruntime +# This code was automatically generated with version 12.9.0. Do not modify it directly. +include "../cyruntime_types.pxi" {{if 'cudaDeviceReset' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceReset() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSynchronize() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetLimit' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetLimit(cyruntime.cudaLimit limit, size_t value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetLimit' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetLimit(size_t* pValue, cyruntime.cudaLimit limit) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cyruntime.cudaChannelFormatDesc* fmtDesc, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetCacheConfig(cyruntime.cudaFuncCache* pCacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetCacheConfig(cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetByPCIBusId' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetPCIBusId' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcGetEventHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcGetEventHandle(cyruntime.cudaIpcEventHandle_t* handle, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcOpenEventHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcOpenEventHandle(cyruntime.cudaEvent_t* event, cyruntime.cudaIpcEventHandle_t handle) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcGetMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcGetMemHandle(cyruntime.cudaIpcMemHandle_t* handle, void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcOpenMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cyruntime.cudaIpcMemHandle_t handle, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcCloseMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cyruntime.cudaFlushGPUDirectRDMAWritesTarget target, cyruntime.cudaFlushGPUDirectRDMAWritesScope scope) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cyruntime.cudaAsyncCallback callbackFunc, void* userData, cyruntime.cudaAsyncCallbackHandle_t* callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cyruntime.cudaAsyncCallbackHandle_t callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetSharedMemConfig(cyruntime.cudaSharedMemConfig* pConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetSharedMemConfig(cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetLastError' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaPeekAtLastError' in found_functions}} -cdef cyruntime.cudaError_t _cudaPeekAtLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetErrorName' in found_functions}} -cdef const char* _cudaGetErrorName(cyruntime.cudaError_t error) except ?NULL nogil +cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil {{endif}} {{if 'cudaGetErrorString' in found_functions}} -cdef const char* _cudaGetErrorString(cyruntime.cudaError_t error) except ?NULL nogil +cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil {{endif}} {{if 'cudaGetDeviceCount' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceCount(int* count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDeviceProperties_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceProperties_v2(cyruntime.cudaDeviceProp* prop, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDeviceProperties_v2(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetAttribute(int* value, cyruntime.cudaDeviceAttr attr, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetDefaultMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetDefaultMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetMemPool(int device, cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetP2PAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetP2PAttribute(int* value, cyruntime.cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaChooseDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaChooseDevice(int* device, const cyruntime.cudaDeviceProp* prop) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaInitDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaSetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaSetDevice(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDevice(int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaSetDeviceFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDeviceFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreate(cyruntime.cudaStream_t* pStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamCreateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreateWithFlags(cyruntime.cudaStream_t* pStream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamCreateWithPriority' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreateWithPriority(cyruntime.cudaStream_t* pStream, unsigned int flags, int priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetPriority' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetPriority(cyruntime.cudaStream_t hStream, int* priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetFlags(cyruntime.cudaStream_t hStream, unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetId' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetId(cyruntime.cudaStream_t hStream, unsigned long long* streamId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetDevice(cyruntime.cudaStream_t hStream, int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaCtxResetPersistingL2Cache' in found_functions}} -cdef cyruntime.cudaError_t _cudaCtxResetPersistingL2Cache() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamCopyAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCopyAttributes(cyruntime.cudaStream_t dst, cyruntime.cudaStream_t src) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, cyruntime.cudaStreamAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamSetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, const cyruntime.cudaStreamAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamDestroy(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamWaitEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamWaitEvent(cyruntime.cudaStream_t stream, cyruntime.cudaEvent_t event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamAddCallback' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamAddCallback(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamSynchronize(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamQuery' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamQuery(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamAttachMemAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamAttachMemAsync(cyruntime.cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamBeginCapture' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamBeginCapture(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamBeginCaptureToGraph' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamBeginCaptureToGraph(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.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 {{endif}} {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} -cdef cyruntime.cudaError_t _cudaThreadExchangeStreamCaptureMode(cyruntime.cudaStreamCaptureMode* mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamEndCapture' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamEndCapture(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamIsCapturing' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamIsCapturing(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* pCaptureStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v2(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef 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) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetCaptureInfo_v3' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v3(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, const cyruntime.cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cyruntime.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 {{endif}} {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamUpdateCaptureDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies_v2(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cyruntime.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 {{endif}} {{if 'cudaEventCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventCreate(cyruntime.cudaEvent_t* event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventCreateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventCreateWithFlags(cyruntime.cudaEvent_t* event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventRecord' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventRecord(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventRecordWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventRecordWithFlags(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventQuery' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventQuery(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventSynchronize(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventDestroy(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventElapsedTime' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventElapsedTime(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventElapsedTime_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventElapsedTime_v2(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaImportExternalMemory' in found_functions}} -cdef cyruntime.cudaError_t _cudaImportExternalMemory(cyruntime.cudaExternalMemory_t* extMem_out, const cyruntime.cudaExternalMemoryHandleDesc* memHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} -cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryBufferDesc* bufferDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmap, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDestroyExternalMemory' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyExternalMemory(cyruntime.cudaExternalMemory_t extMem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaImportExternalSemaphore' in found_functions}} -cdef cyruntime.cudaError_t _cudaImportExternalSemaphore(cyruntime.cudaExternalSemaphore_t* extSem_out, const cyruntime.cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDestroyExternalSemaphore' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyExternalSemaphore(cyruntime.cudaExternalSemaphore_t extSem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFuncSetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetCacheConfig(const void* func, cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFuncGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncGetAttributes(cyruntime.cudaFuncAttributes* attr, const void* func) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFuncSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetAttribute(const void* func, cyruntime.cudaFuncAttribute attr, int value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLaunchHostFunc' in found_functions}} -cdef cyruntime.cudaError_t _cudaLaunchHostFunc(cyruntime.cudaStream_t stream, cyruntime.cudaHostFn_t fn, void* userData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFuncSetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocManaged' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMalloc' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocHost' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocPitch' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFree' in found_functions}} -cdef cyruntime.cudaError_t _cudaFree(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFreeHost' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeHost(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFreeArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeArray(cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFreeMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeMipmappedArray(cyruntime.cudaMipmappedArray_t mipmappedArray) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostAlloc' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostRegister' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostUnregister' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostUnregister(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostGetDevicePointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMalloc3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc3D(cyruntime.cudaPitchedPtr* pitchedDevPtr, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMalloc3DArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc3DArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetMipmappedArrayLevel' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetMipmappedArrayLevel(cyruntime.cudaArray_t* levelArray, cyruntime.cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3D(const cyruntime.cudaMemcpy3DParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy3DPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DPeer(const cyruntime.cudaMemcpy3DPeerParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy3DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DAsync(const cyruntime.cudaMemcpy3DParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy3DPeerAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DPeerAsync(const cyruntime.cudaMemcpy3DPeerParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemGetInfo' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaArrayGetInfo' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetInfo(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent* extent, unsigned int* flags, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaArrayGetPlane' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetPlane(cyruntime.cudaArray_t* pPlaneArray, cyruntime.cudaArray_t hArray, unsigned int planeIdx) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaArrayGetMemoryRequirements' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaArray_t array, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} -cdef cyruntime.cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaMipmappedArray_t mipmap, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaArrayGetSparseProperties' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} -cdef cyruntime.cudaError_t _cudaMipmappedArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaMipmappedArray_t mipmap) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpyPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy2D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DFromArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DArrayToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpyPeerAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpyBatchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, cyruntime.cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy3DBatchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cyruntime.cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy2DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DToArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemset' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemset2D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemset3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset3D(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemsetAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemset2DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemset3DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset3DAsync(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPrefetchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPrefetchAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cyruntime.cudaMemLocation location, unsigned int flags, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemAdvise' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemAdvise_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, cyruntime.cudaMemLocation location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemRangeGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cyruntime.cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemRangeGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cyruntime.cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyFromArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyFromArray(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyArrayToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyToArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyFromArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMallocAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFreeAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeAsync(void* devPtr, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolTrimTo' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolTrimTo(cyruntime.cudaMemPool_t memPool, size_t minBytesToKeep) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolSetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolGetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolSetAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolSetAccess(cyruntime.cudaMemPool_t memPool, const cyruntime.cudaMemAccessDesc* descList, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolGetAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolGetAccess(cyruntime.cudaMemAccessFlags* flags, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemLocation* location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolCreate(cyruntime.cudaMemPool_t* memPool, const cyruntime.cudaMemPoolProps* poolProps) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolDestroy(cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocFromPoolAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cyruntime.cudaMemPool_t memPool, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolExportToShareableHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolImportFromShareableHandle(cyruntime.cudaMemPool_t* memPool, void* shareableHandle, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolExportPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolExportPointer(cyruntime.cudaMemPoolPtrExportData* exportData, void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolImportPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolImportPointer(void** ptr, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolPtrExportData* exportData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaPointerGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaPointerGetAttributes(cyruntime.cudaPointerAttributes* attributes, const void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceCanAccessPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceEnablePeerAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceDisablePeerAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsUnregisterResource' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsUnregisterResource(cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceSetMapFlags(cyruntime.cudaGraphicsResource_t resource, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsMapResources' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsMapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsUnmapResources' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsUnmapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsSubResourceGetMappedArray(cyruntime.cudaArray_t* array, cyruntime.cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetChannelDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetChannelDesc(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaArray_const_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaCreateChannelDesc' in found_functions}} -cdef cyruntime.cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cyruntime.cudaChannelFormatKind f) except* nogil +cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil {{endif}} {{if 'cudaCreateTextureObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaCreateTextureObject(cyruntime.cudaTextureObject_t* pTexObject, const cyruntime.cudaResourceDesc* pResDesc, const cyruntime.cudaTextureDesc* pTexDesc, const cyruntime.cudaResourceViewDesc* pResViewDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDestroyTextureObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyTextureObject(cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetTextureObjectResourceDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetTextureObjectTextureDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectTextureDesc(cyruntime.cudaTextureDesc* pTexDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceViewDesc(cyruntime.cudaResourceViewDesc* pResViewDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaCreateSurfaceObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaCreateSurfaceObject(cyruntime.cudaSurfaceObject_t* pSurfObject, const cyruntime.cudaResourceDesc* pResDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDestroySurfaceObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroySurfaceObject(cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetSurfaceObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDriverGetVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaRuntimeGetVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphCreate(cyruntime.cudaGraph_t* pGraph, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddKernelNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddKernelNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphKernelNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphKernelNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeCopyAttributes(cyruntime.cudaGraphNode_t hSrc, cyruntime.cudaGraphNode_t hDst) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, cyruntime.cudaKernelNodeAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, const cyruntime.cudaKernelNodeAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddMemcpyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemcpy3DParms* pCopyParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphAddMemcpyNode1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode1D(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams1D(cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddMemsetNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemsetNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemsetParams* pMemsetParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphMemsetNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemsetNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemsetNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemsetNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddHostNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddHostNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphHostNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphHostNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphHostNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphHostNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddChildGraphNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddChildGraphNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraph_t childGraph) except ?cyruntime.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 {{endif}} {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphChildGraphNodeGetGraph(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddEmptyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEmptyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddEventRecordNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEventRecordNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.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 {{endif}} {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddEventWaitNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEventWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.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 {{endif}} {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreSignalNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreWaitNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddMemAllocNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemAllocNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaMemAllocNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemAllocNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemAllocNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddMemFreeNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemFreeNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemFreeNodeGetParams(cyruntime.cudaGraphNode_t node, void* dptr_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGraphMemTrim' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphClone' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphClone(cyruntime.cudaGraph_t* pGraphClone, cyruntime.cudaGraph_t originalGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeFindInClone' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeFindInClone(cyruntime.cudaGraphNode_t* pNode, cyruntime.cudaGraphNode_t originalNode, cyruntime.cudaGraph_t clonedGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetType' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetType(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeType* pType) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphGetNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* nodes, size_t* numNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphGetRootNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetRootNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphGetEdges' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetEdges(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphGetEdges_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetEdges_v2(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, cyruntime.cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetDependentNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetDependentNodes_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.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 {{endif}} {{if 'cudaGraphRemoveDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphRemoveDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.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 {{endif}} {{if 'cudaGraphDestroyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDestroyNode(cyruntime.cudaGraphNode_t node) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphInstantiate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiate(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphInstantiateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiateWithFlags(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphInstantiateWithParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiateWithParams(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, cyruntime.cudaGraphInstantiateParams* instantiateParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecGetFlags(cyruntime.cudaGraphExec_t graphExec, unsigned long long* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecKernelNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemsetNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecHostNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecHostNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecChildGraphNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t childGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeSetEnabled' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeSetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetEnabled' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecUpdate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecUpdate(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraph_t hGraph, cyruntime.cudaGraphExecUpdateResultInfo* resultInfo) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphUpload' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphUpload(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphLaunch' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphLaunch(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecDestroy(cyruntime.cudaGraphExec_t graphExec) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDestroy(cyruntime.cudaGraph_t graph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphDebugDotPrint' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDebugDotPrint(cyruntime.cudaGraph_t graph, const char* path, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaUserObjectCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectCreate(cyruntime.cudaUserObject_t* object_out, void* ptr, cyruntime.cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaUserObjectRetain' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectRetain(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaUserObjectRelease' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectRelease(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphRetainUserObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRetainUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphReleaseUserObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphReleaseUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddNode_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddNode_v2(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeSetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecNodeSetParams(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphConditionalHandleCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphConditionalHandleCreate(cyruntime.cudaGraphConditionalHandle* pHandle_out, cyruntime.cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDriverEntryPoint' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDriverEntryPointByVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryLoadData' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryLoadData(cyruntime.cudaLibrary_t* library, const void* code, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.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 {{endif}} {{if 'cudaLibraryLoadFromFile' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryLoadFromFile(cyruntime.cudaLibrary_t* library, const char* fileName, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.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 {{endif}} {{if 'cudaLibraryUnload' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryUnload(cyruntime.cudaLibrary_t library) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetKernel' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetKernel(cyruntime.cudaKernel_t* pKernel, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetGlobal' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetManaged' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetUnifiedFunction' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cyruntime.cudaLibrary_t library, const char* symbol) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetKernelCount' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryEnumerateKernels' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryEnumerateKernels(cyruntime.cudaKernel_t* kernels, unsigned int numKernels, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaKernelSetAttributeForDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaKernelSetAttributeForDevice(cyruntime.cudaKernel_t kernel, cyruntime.cudaFuncAttribute attr, int value, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetExportTable' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetExportTable(const void** ppExportTable, const cyruntime.cudaUUID_t* pExportTableId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetKernel' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetKernel(cyruntime.cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'make_cudaPitchedPtr' in found_functions}} -cdef cyruntime.cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil +cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil {{endif}} {{if 'make_cudaPos' in found_functions}} -cdef cyruntime.cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil +cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil {{endif}} {{if 'make_cudaExtent' in found_functions}} -cdef cyruntime.cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil +cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil {{endif}} {{if 'cudaProfilerStart' in found_functions}} -cdef cyruntime.cudaError_t _cudaProfilerStart() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaProfilerStop' in found_functions}} -cdef cyruntime.cudaError_t _cudaProfilerStop() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxi.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxi.in deleted file mode 100644 index 6d9a38e3b..000000000 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxi.in +++ /dev/null @@ -1,1497 +0,0 @@ -# Copyright 2021-2025 NVIDIA Corporation. All rights reserved. -# -# Please refer to the NVIDIA end user license agreement (EULA) associated -# with this source code for terms and conditions that govern your use of -# this software. Any use, reproduction, disclosure, or distribution of -# this software and related documentation outside the terms of the EULA -# is strictly prohibited. -# -# This code was automatically generated with version 12.8.0. Do not modify it directly. -cimport cython -cimport cuda.bindings.cyruntime as cyruntime - -cdef extern from "cuda_runtime_api.h": - - {{if 'cudaDeviceReset' in found_functions}} - - cyruntime.cudaError_t cudaDeviceReset() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceSynchronize' in found_functions}} - - cyruntime.cudaError_t cudaDeviceSynchronize() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceSetLimit' in found_functions}} - - cyruntime.cudaError_t cudaDeviceSetLimit(cyruntime.cudaLimit limit, size_t value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetLimit' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetLimit(size_t* pValue, cyruntime.cudaLimit limit) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cyruntime.cudaChannelFormatDesc* fmtDesc, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetCacheConfig' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetCacheConfig(cyruntime.cudaFuncCache* pCacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceSetCacheConfig' in found_functions}} - - cyruntime.cudaError_t cudaDeviceSetCacheConfig(cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetByPCIBusId' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetPCIBusId' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaIpcGetEventHandle' in found_functions}} - - cyruntime.cudaError_t cudaIpcGetEventHandle(cyruntime.cudaIpcEventHandle_t* handle, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaIpcOpenEventHandle' in found_functions}} - - cyruntime.cudaError_t cudaIpcOpenEventHandle(cyruntime.cudaEvent_t* event, cyruntime.cudaIpcEventHandle_t handle) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaIpcGetMemHandle' in found_functions}} - - cyruntime.cudaError_t cudaIpcGetMemHandle(cyruntime.cudaIpcMemHandle_t* handle, void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaIpcOpenMemHandle' in found_functions}} - - cyruntime.cudaError_t cudaIpcOpenMemHandle(void** devPtr, cyruntime.cudaIpcMemHandle_t handle, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaIpcCloseMemHandle' in found_functions}} - - cyruntime.cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} - - cyruntime.cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cyruntime.cudaFlushGPUDirectRDMAWritesTarget target, cyruntime.cudaFlushGPUDirectRDMAWritesScope scope) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} - - cyruntime.cudaError_t cudaDeviceRegisterAsyncNotification(int device, cyruntime.cudaAsyncCallback callbackFunc, void* userData, cyruntime.cudaAsyncCallbackHandle_t* callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} - - cyruntime.cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cyruntime.cudaAsyncCallbackHandle_t callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetSharedMemConfig' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetSharedMemConfig(cyruntime.cudaSharedMemConfig* pConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceSetSharedMemConfig' in found_functions}} - - cyruntime.cudaError_t cudaDeviceSetSharedMemConfig(cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetLastError' in found_functions}} - - cyruntime.cudaError_t cudaGetLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaPeekAtLastError' in found_functions}} - - cyruntime.cudaError_t cudaPeekAtLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetErrorName' in found_functions}} - - const char* cudaGetErrorName(cyruntime.cudaError_t error) except ?NULL nogil - - {{endif}} - {{if 'cudaGetErrorString' in found_functions}} - - const char* cudaGetErrorString(cyruntime.cudaError_t error) except ?NULL nogil - - {{endif}} - {{if 'cudaGetDeviceCount' in found_functions}} - - cyruntime.cudaError_t cudaGetDeviceCount(int* count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetDeviceProperties_v2' in found_functions}} - - cyruntime.cudaError_t cudaGetDeviceProperties_v2(cyruntime.cudaDeviceProp* prop, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetAttribute(int* value, cyruntime.cudaDeviceAttr attr, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetDefaultMemPool' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetDefaultMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceSetMemPool' in found_functions}} - - cyruntime.cudaError_t cudaDeviceSetMemPool(int device, cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetMemPool' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetP2PAttribute' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetP2PAttribute(int* value, cyruntime.cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaChooseDevice' in found_functions}} - - cyruntime.cudaError_t cudaChooseDevice(int* device, const cyruntime.cudaDeviceProp* prop) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaInitDevice' in found_functions}} - - cyruntime.cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaSetDevice' in found_functions}} - - cyruntime.cudaError_t cudaSetDevice(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetDevice' in found_functions}} - - cyruntime.cudaError_t cudaGetDevice(int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaSetDeviceFlags' in found_functions}} - - cyruntime.cudaError_t cudaSetDeviceFlags(unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetDeviceFlags' in found_functions}} - - cyruntime.cudaError_t cudaGetDeviceFlags(unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamCreate' in found_functions}} - - cyruntime.cudaError_t cudaStreamCreate(cyruntime.cudaStream_t* pStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamCreateWithFlags' in found_functions}} - - cyruntime.cudaError_t cudaStreamCreateWithFlags(cyruntime.cudaStream_t* pStream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamCreateWithPriority' in found_functions}} - - cyruntime.cudaError_t cudaStreamCreateWithPriority(cyruntime.cudaStream_t* pStream, unsigned int flags, int priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamGetPriority' in found_functions}} - - cyruntime.cudaError_t cudaStreamGetPriority(cyruntime.cudaStream_t hStream, int* priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamGetFlags' in found_functions}} - - cyruntime.cudaError_t cudaStreamGetFlags(cyruntime.cudaStream_t hStream, unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamGetId' in found_functions}} - - cyruntime.cudaError_t cudaStreamGetId(cyruntime.cudaStream_t hStream, unsigned long long* streamId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamGetDevice' in found_functions}} - - cyruntime.cudaError_t cudaStreamGetDevice(cyruntime.cudaStream_t hStream, int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaCtxResetPersistingL2Cache' in found_functions}} - - cyruntime.cudaError_t cudaCtxResetPersistingL2Cache() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamCopyAttributes' in found_functions}} - - cyruntime.cudaError_t cudaStreamCopyAttributes(cyruntime.cudaStream_t dst, cyruntime.cudaStream_t src) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamGetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaStreamGetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, cyruntime.cudaStreamAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamSetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaStreamSetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, const cyruntime.cudaStreamAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamDestroy' in found_functions}} - - cyruntime.cudaError_t cudaStreamDestroy(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamWaitEvent' in found_functions}} - - cyruntime.cudaError_t cudaStreamWaitEvent(cyruntime.cudaStream_t stream, cyruntime.cudaEvent_t event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamAddCallback' in found_functions}} - - cyruntime.cudaError_t cudaStreamAddCallback(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamSynchronize' in found_functions}} - - cyruntime.cudaError_t cudaStreamSynchronize(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamQuery' in found_functions}} - - cyruntime.cudaError_t cudaStreamQuery(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamAttachMemAsync' in found_functions}} - - cyruntime.cudaError_t cudaStreamAttachMemAsync(cyruntime.cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamBeginCapture' in found_functions}} - - cyruntime.cudaError_t cudaStreamBeginCapture(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamBeginCaptureToGraph' in found_functions}} - - cyruntime.cudaError_t cudaStreamBeginCaptureToGraph(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} - - cyruntime.cudaError_t cudaThreadExchangeStreamCaptureMode(cyruntime.cudaStreamCaptureMode* mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamEndCapture' in found_functions}} - - cyruntime.cudaError_t cudaStreamEndCapture(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamIsCapturing' in found_functions}} - - cyruntime.cudaError_t cudaStreamIsCapturing(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* pCaptureStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}} - - cyruntime.cudaError_t cudaStreamGetCaptureInfo_v2_ptsz(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}} - - cyruntime.cudaError_t cudaStreamGetCaptureInfo_v2(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamGetCaptureInfo_v3' in found_functions}} - - cyruntime.cudaError_t cudaStreamGetCaptureInfo_v3(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, const cyruntime.cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} - - cyruntime.cudaError_t cudaStreamUpdateCaptureDependencies(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaStreamUpdateCaptureDependencies_v2' in found_functions}} - - cyruntime.cudaError_t cudaStreamUpdateCaptureDependencies_v2(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventCreate' in found_functions}} - - cyruntime.cudaError_t cudaEventCreate(cyruntime.cudaEvent_t* event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventCreateWithFlags' in found_functions}} - - cyruntime.cudaError_t cudaEventCreateWithFlags(cyruntime.cudaEvent_t* event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventRecord' in found_functions}} - - cyruntime.cudaError_t cudaEventRecord(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventRecordWithFlags' in found_functions}} - - cyruntime.cudaError_t cudaEventRecordWithFlags(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventQuery' in found_functions}} - - cyruntime.cudaError_t cudaEventQuery(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventSynchronize' in found_functions}} - - cyruntime.cudaError_t cudaEventSynchronize(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventDestroy' in found_functions}} - - cyruntime.cudaError_t cudaEventDestroy(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventElapsedTime' in found_functions}} - - cyruntime.cudaError_t cudaEventElapsedTime(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaEventElapsedTime_v2' in found_functions}} - - cyruntime.cudaError_t cudaEventElapsedTime_v2(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaImportExternalMemory' in found_functions}} - - cyruntime.cudaError_t cudaImportExternalMemory(cyruntime.cudaExternalMemory_t* extMem_out, const cyruntime.cudaExternalMemoryHandleDesc* memHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} - - cyruntime.cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryBufferDesc* bufferDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} - - cyruntime.cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmap, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDestroyExternalMemory' in found_functions}} - - cyruntime.cudaError_t cudaDestroyExternalMemory(cyruntime.cudaExternalMemory_t extMem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaImportExternalSemaphore' in found_functions}} - - cyruntime.cudaError_t cudaImportExternalSemaphore(cyruntime.cudaExternalSemaphore_t* extSem_out, const cyruntime.cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}} - - cyruntime.cudaError_t cudaSignalExternalSemaphoresAsync_v2_ptsz(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}} - - cyruntime.cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}} - - cyruntime.cudaError_t cudaWaitExternalSemaphoresAsync_v2_ptsz(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}} - - cyruntime.cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDestroyExternalSemaphore' in found_functions}} - - cyruntime.cudaError_t cudaDestroyExternalSemaphore(cyruntime.cudaExternalSemaphore_t extSem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFuncSetCacheConfig' in found_functions}} - - cyruntime.cudaError_t cudaFuncSetCacheConfig(const void* func, cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFuncGetAttributes' in found_functions}} - - cyruntime.cudaError_t cudaFuncGetAttributes(cyruntime.cudaFuncAttributes* attr, const void* func) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFuncSetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaFuncSetAttribute(const void* func, cyruntime.cudaFuncAttribute attr, int value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLaunchHostFunc' in found_functions}} - - cyruntime.cudaError_t cudaLaunchHostFunc(cyruntime.cudaStream_t stream, cyruntime.cudaHostFn_t fn, void* userData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFuncSetSharedMemConfig' in found_functions}} - - cyruntime.cudaError_t cudaFuncSetSharedMemConfig(const void* func, cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} - - cyruntime.cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} - - cyruntime.cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} - - cyruntime.cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMallocManaged' in found_functions}} - - cyruntime.cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMalloc' in found_functions}} - - cyruntime.cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMallocHost' in found_functions}} - - cyruntime.cudaError_t cudaMallocHost(void** ptr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMallocPitch' in found_functions}} - - cyruntime.cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMallocArray' in found_functions}} - - cyruntime.cudaError_t cudaMallocArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFree' in found_functions}} - - cyruntime.cudaError_t cudaFree(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFreeHost' in found_functions}} - - cyruntime.cudaError_t cudaFreeHost(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFreeArray' in found_functions}} - - cyruntime.cudaError_t cudaFreeArray(cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFreeMipmappedArray' in found_functions}} - - cyruntime.cudaError_t cudaFreeMipmappedArray(cyruntime.cudaMipmappedArray_t mipmappedArray) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaHostAlloc' in found_functions}} - - cyruntime.cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaHostRegister' in found_functions}} - - cyruntime.cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaHostUnregister' in found_functions}} - - cyruntime.cudaError_t cudaHostUnregister(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaHostGetDevicePointer' in found_functions}} - - cyruntime.cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaHostGetFlags' in found_functions}} - - cyruntime.cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMalloc3D' in found_functions}} - - cyruntime.cudaError_t cudaMalloc3D(cyruntime.cudaPitchedPtr* pitchedDevPtr, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMalloc3DArray' in found_functions}} - - cyruntime.cudaError_t cudaMalloc3DArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMallocMipmappedArray' in found_functions}} - - cyruntime.cudaError_t cudaMallocMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetMipmappedArrayLevel' in found_functions}} - - cyruntime.cudaError_t cudaGetMipmappedArrayLevel(cyruntime.cudaArray_t* levelArray, cyruntime.cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy3D' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy3D(const cyruntime.cudaMemcpy3DParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy3DPeer' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy3DPeer(const cyruntime.cudaMemcpy3DPeerParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy3DAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy3DAsync(const cyruntime.cudaMemcpy3DParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy3DPeerAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy3DPeerAsync(const cyruntime.cudaMemcpy3DPeerParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemGetInfo' in found_functions}} - - cyruntime.cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaArrayGetInfo' in found_functions}} - - cyruntime.cudaError_t cudaArrayGetInfo(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent* extent, unsigned int* flags, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaArrayGetPlane' in found_functions}} - - cyruntime.cudaError_t cudaArrayGetPlane(cyruntime.cudaArray_t* pPlaneArray, cyruntime.cudaArray_t hArray, unsigned int planeIdx) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaArrayGetMemoryRequirements' in found_functions}} - - cyruntime.cudaError_t cudaArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaArray_t array, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} - - cyruntime.cudaError_t cudaMipmappedArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaMipmappedArray_t mipmap, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaArrayGetSparseProperties' in found_functions}} - - cyruntime.cudaError_t cudaArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} - - cyruntime.cudaError_t cudaMipmappedArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaMipmappedArray_t mipmap) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyPeer' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy2D' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy2DToArray' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy2DToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy2DFromArray' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy2DArrayToArray' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy2DArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyPeerAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyBatchAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, cyruntime.cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy3DBatchAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cyruntime.cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy2DAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy2DToArrayAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy2DToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemset' in found_functions}} - - cyruntime.cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemset2D' in found_functions}} - - cyruntime.cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemset3D' in found_functions}} - - cyruntime.cudaError_t cudaMemset3D(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemsetAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemset2DAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemset3DAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemset3DAsync(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPrefetchAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPrefetchAsync_v2' in found_functions}} - - cyruntime.cudaError_t cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cyruntime.cudaMemLocation location, unsigned int flags, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemAdvise' in found_functions}} - - cyruntime.cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemAdvise_v2' in found_functions}} - - cyruntime.cudaError_t cudaMemAdvise_v2(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, cyruntime.cudaMemLocation location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemRangeGetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cyruntime.cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemRangeGetAttributes' in found_functions}} - - cyruntime.cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cyruntime.cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyToArray' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyFromArray' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyFromArray(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyArrayToArray' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyToArrayAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemcpyFromArrayAsync' in found_functions}} - - cyruntime.cudaError_t cudaMemcpyFromArrayAsync(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMallocAsync' in found_functions}} - - cyruntime.cudaError_t cudaMallocAsync(void** devPtr, size_t size, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaFreeAsync' in found_functions}} - - cyruntime.cudaError_t cudaFreeAsync(void* devPtr, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolTrimTo' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolTrimTo(cyruntime.cudaMemPool_t memPool, size_t minBytesToKeep) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolSetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolSetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolGetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolGetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolSetAccess' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolSetAccess(cyruntime.cudaMemPool_t memPool, const cyruntime.cudaMemAccessDesc* descList, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolGetAccess' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolGetAccess(cyruntime.cudaMemAccessFlags* flags, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemLocation* location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolCreate' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolCreate(cyruntime.cudaMemPool_t* memPool, const cyruntime.cudaMemPoolProps* poolProps) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolDestroy' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolDestroy(cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMallocFromPoolAsync' in found_functions}} - - cyruntime.cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cyruntime.cudaMemPool_t memPool, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolExportToShareableHandle' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolImportFromShareableHandle(cyruntime.cudaMemPool_t* memPool, void* shareableHandle, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolExportPointer' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolExportPointer(cyruntime.cudaMemPoolPtrExportData* exportData, void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaMemPoolImportPointer' in found_functions}} - - cyruntime.cudaError_t cudaMemPoolImportPointer(void** ptr, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolPtrExportData* exportData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaPointerGetAttributes' in found_functions}} - - cyruntime.cudaError_t cudaPointerGetAttributes(cyruntime.cudaPointerAttributes* attributes, const void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceCanAccessPeer' in found_functions}} - - cyruntime.cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceEnablePeerAccess' in found_functions}} - - cyruntime.cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceDisablePeerAccess' in found_functions}} - - cyruntime.cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphicsUnregisterResource' in found_functions}} - - cyruntime.cudaError_t cudaGraphicsUnregisterResource(cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} - - cyruntime.cudaError_t cudaGraphicsResourceSetMapFlags(cyruntime.cudaGraphicsResource_t resource, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphicsMapResources' in found_functions}} - - cyruntime.cudaError_t cudaGraphicsMapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphicsUnmapResources' in found_functions}} - - cyruntime.cudaError_t cudaGraphicsUnmapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} - - cyruntime.cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} - - cyruntime.cudaError_t cudaGraphicsSubResourceGetMappedArray(cyruntime.cudaArray_t* array, cyruntime.cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} - - cyruntime.cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetChannelDesc' in found_functions}} - - cyruntime.cudaError_t cudaGetChannelDesc(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaArray_const_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaCreateChannelDesc' in found_functions}} - - cyruntime.cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cyruntime.cudaChannelFormatKind f) except* nogil - - {{endif}} - {{if 'cudaCreateTextureObject' in found_functions}} - - cyruntime.cudaError_t cudaCreateTextureObject(cyruntime.cudaTextureObject_t* pTexObject, const cyruntime.cudaResourceDesc* pResDesc, const cyruntime.cudaTextureDesc* pTexDesc, const cyruntime.cudaResourceViewDesc* pResViewDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDestroyTextureObject' in found_functions}} - - cyruntime.cudaError_t cudaDestroyTextureObject(cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetTextureObjectResourceDesc' in found_functions}} - - cyruntime.cudaError_t cudaGetTextureObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetTextureObjectTextureDesc' in found_functions}} - - cyruntime.cudaError_t cudaGetTextureObjectTextureDesc(cyruntime.cudaTextureDesc* pTexDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} - - cyruntime.cudaError_t cudaGetTextureObjectResourceViewDesc(cyruntime.cudaResourceViewDesc* pResViewDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaCreateSurfaceObject' in found_functions}} - - cyruntime.cudaError_t cudaCreateSurfaceObject(cyruntime.cudaSurfaceObject_t* pSurfObject, const cyruntime.cudaResourceDesc* pResDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDestroySurfaceObject' in found_functions}} - - cyruntime.cudaError_t cudaDestroySurfaceObject(cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} - - cyruntime.cudaError_t cudaGetSurfaceObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDriverGetVersion' in found_functions}} - - cyruntime.cudaError_t cudaDriverGetVersion(int* driverVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaRuntimeGetVersion' in found_functions}} - - cyruntime.cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphCreate' in found_functions}} - - cyruntime.cudaError_t cudaGraphCreate(cyruntime.cudaGraph_t* pGraph, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddKernelNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddKernelNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphKernelNodeGetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphKernelNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphKernelNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphKernelNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} - - cyruntime.cudaError_t cudaGraphKernelNodeCopyAttributes(cyruntime.cudaGraphNode_t hSrc, cyruntime.cudaGraphNode_t hDst) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaGraphKernelNodeGetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, cyruntime.cudaKernelNodeAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} - - cyruntime.cudaError_t cudaGraphKernelNodeSetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, const cyruntime.cudaKernelNodeAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddMemcpyNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddMemcpyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemcpy3DParms* pCopyParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddMemcpyNode1D' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddMemcpyNode1D(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphMemcpyNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphMemcpyNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} - - cyruntime.cudaError_t cudaGraphMemcpyNodeSetParams1D(cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddMemsetNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddMemsetNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemsetParams* pMemsetParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphMemsetNodeGetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphMemsetNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphMemsetNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphMemsetNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddHostNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddHostNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphHostNodeGetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphHostNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphHostNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphHostNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddChildGraphNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddChildGraphNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraph_t childGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} - - cyruntime.cudaError_t cudaGraphChildGraphNodeGetGraph(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddEmptyNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddEmptyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddEventRecordNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddEventRecordNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} - - cyruntime.cudaError_t cudaGraphEventRecordNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} - - cyruntime.cudaError_t cudaGraphEventRecordNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddEventWaitNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddEventWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} - - cyruntime.cudaError_t cudaGraphEventWaitNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} - - cyruntime.cudaError_t cudaGraphEventWaitNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreSignalNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreWaitNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddMemAllocNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddMemAllocNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaMemAllocNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphMemAllocNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemAllocNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddMemFreeNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddMemFreeNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphMemFreeNodeGetParams(cyruntime.cudaGraphNode_t node, void* dptr_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGraphMemTrim' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGraphMemTrim(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} - - cyruntime.cudaError_t cudaDeviceGetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} - - cyruntime.cudaError_t cudaDeviceSetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphClone' in found_functions}} - - cyruntime.cudaError_t cudaGraphClone(cyruntime.cudaGraph_t* pGraphClone, cyruntime.cudaGraph_t originalGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeFindInClone' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeFindInClone(cyruntime.cudaGraphNode_t* pNode, cyruntime.cudaGraphNode_t originalNode, cyruntime.cudaGraph_t clonedGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeGetType' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeGetType(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeType* pType) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphGetNodes' in found_functions}} - - cyruntime.cudaError_t cudaGraphGetNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* nodes, size_t* numNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphGetRootNodes' in found_functions}} - - cyruntime.cudaError_t cudaGraphGetRootNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphGetEdges' in found_functions}} - - cyruntime.cudaError_t cudaGraphGetEdges(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphGetEdges_v2' in found_functions}} - - cyruntime.cudaError_t cudaGraphGetEdges_v2(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, cyruntime.cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeGetDependencies' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeGetDependencies(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeGetDependencies_v2' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeGetDependencies_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeGetDependentNodes' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeGetDependentNodes(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeGetDependentNodes_v2' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeGetDependentNodes_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddDependencies' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddDependencies_v2' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphRemoveDependencies' in found_functions}} - - cyruntime.cudaError_t cudaGraphRemoveDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphRemoveDependencies_v2' in found_functions}} - - cyruntime.cudaError_t cudaGraphRemoveDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphDestroyNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphDestroyNode(cyruntime.cudaGraphNode_t node) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphInstantiate' in found_functions}} - - cyruntime.cudaError_t cudaGraphInstantiate(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphInstantiateWithFlags' in found_functions}} - - cyruntime.cudaError_t cudaGraphInstantiateWithFlags(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphInstantiateWithParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphInstantiateWithParams(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, cyruntime.cudaGraphInstantiateParams* instantiateParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecGetFlags' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecGetFlags(cyruntime.cudaGraphExec_t graphExec, unsigned long long* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecKernelNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecMemcpyNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecMemsetNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecHostNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecHostNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecChildGraphNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t childGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecEventRecordNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecEventWaitNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeSetEnabled' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeSetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeGetEnabled' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeGetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecUpdate' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecUpdate(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraph_t hGraph, cyruntime.cudaGraphExecUpdateResultInfo* resultInfo) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphUpload' in found_functions}} - - cyruntime.cudaError_t cudaGraphUpload(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphLaunch' in found_functions}} - - cyruntime.cudaError_t cudaGraphLaunch(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecDestroy' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecDestroy(cyruntime.cudaGraphExec_t graphExec) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphDestroy' in found_functions}} - - cyruntime.cudaError_t cudaGraphDestroy(cyruntime.cudaGraph_t graph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphDebugDotPrint' in found_functions}} - - cyruntime.cudaError_t cudaGraphDebugDotPrint(cyruntime.cudaGraph_t graph, const char* path, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaUserObjectCreate' in found_functions}} - - cyruntime.cudaError_t cudaUserObjectCreate(cyruntime.cudaUserObject_t* object_out, void* ptr, cyruntime.cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaUserObjectRetain' in found_functions}} - - cyruntime.cudaError_t cudaUserObjectRetain(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaUserObjectRelease' in found_functions}} - - cyruntime.cudaError_t cudaUserObjectRelease(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphRetainUserObject' in found_functions}} - - cyruntime.cudaError_t cudaGraphRetainUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphReleaseUserObject' in found_functions}} - - cyruntime.cudaError_t cudaGraphReleaseUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddNode' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphAddNode_v2' in found_functions}} - - cyruntime.cudaError_t cudaGraphAddNode_v2(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphNodeSetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphExecNodeSetParams' in found_functions}} - - cyruntime.cudaError_t cudaGraphExecNodeSetParams(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGraphConditionalHandleCreate' in found_functions}} - - cyruntime.cudaError_t cudaGraphConditionalHandleCreate(cyruntime.cudaGraphConditionalHandle* pHandle_out, cyruntime.cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetDriverEntryPoint' in found_functions}} - - cyruntime.cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetDriverEntryPointByVersion' in found_functions}} - - cyruntime.cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryLoadData' in found_functions}} - - cyruntime.cudaError_t cudaLibraryLoadData(cyruntime.cudaLibrary_t* library, const void* code, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryLoadFromFile' in found_functions}} - - cyruntime.cudaError_t cudaLibraryLoadFromFile(cyruntime.cudaLibrary_t* library, const char* fileName, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryUnload' in found_functions}} - - cyruntime.cudaError_t cudaLibraryUnload(cyruntime.cudaLibrary_t library) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryGetKernel' in found_functions}} - - cyruntime.cudaError_t cudaLibraryGetKernel(cyruntime.cudaKernel_t* pKernel, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryGetGlobal' in found_functions}} - - cyruntime.cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryGetManaged' in found_functions}} - - cyruntime.cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryGetUnifiedFunction' in found_functions}} - - cyruntime.cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cyruntime.cudaLibrary_t library, const char* symbol) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryGetKernelCount' in found_functions}} - - cyruntime.cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaLibraryEnumerateKernels' in found_functions}} - - cyruntime.cudaError_t cudaLibraryEnumerateKernels(cyruntime.cudaKernel_t* kernels, unsigned int numKernels, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaKernelSetAttributeForDevice' in found_functions}} - - cyruntime.cudaError_t cudaKernelSetAttributeForDevice(cyruntime.cudaKernel_t kernel, cyruntime.cudaFuncAttribute attr, int value, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetExportTable' in found_functions}} - - cyruntime.cudaError_t cudaGetExportTable(const void** ppExportTable, const cyruntime.cudaUUID_t* pExportTableId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaGetKernel' in found_functions}} - - cyruntime.cudaError_t cudaGetKernel(cyruntime.cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - -cdef extern from "cuda_runtime.h": - - {{if 'make_cudaPitchedPtr' in found_functions}} - - cyruntime.cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil - - {{endif}} - {{if 'make_cudaPos' in found_functions}} - - cyruntime.cudaPos make_cudaPos(size_t x, size_t y, size_t z) except* nogil - - {{endif}} - {{if 'make_cudaExtent' in found_functions}} - - cyruntime.cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) except* nogil - - {{endif}} - -cdef extern from "cuda_profiler_api.h": - - {{if 'cudaProfilerStart' in found_functions}} - - cyruntime.cudaError_t cudaProfilerStart() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - {{if 'cudaProfilerStop' in found_functions}} - - cyruntime.cudaError_t cudaProfilerStop() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil - - {{endif}} - - diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in index ce5214b5b..db5d7ada9 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pyx.in @@ -6,11 +6,12 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. -include "cyruntime.pxi" +# This code was automatically generated with version 12.9.0. Do not modify it directly. +include "../cyruntime_functions.pxi" import os cimport cuda.bindings._bindings.cyruntime_ptds as ptds +cimport cython cdef bint __cudaPythonInit = False cdef bint __usePTDS = False @@ -26,7 +27,7 @@ cdef int cudaPythonInit() except -1 nogil: {{if 'cudaDeviceReset' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceReset() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceReset() @@ -35,7 +36,7 @@ cdef cyruntime.cudaError_t _cudaDeviceReset() except ?cyruntime.cudaErrorCallReq {{if 'cudaDeviceSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSynchronize() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSynchronize() @@ -44,7 +45,7 @@ cdef cyruntime.cudaError_t _cudaDeviceSynchronize() except ?cyruntime.cudaErrorC {{if 'cudaDeviceSetLimit' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetLimit(cyruntime.cudaLimit limit, size_t value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetLimit(limit, value) @@ -53,7 +54,7 @@ cdef cyruntime.cudaError_t _cudaDeviceSetLimit(cyruntime.cudaLimit limit, size_t {{if 'cudaDeviceGetLimit' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetLimit(size_t* pValue, cyruntime.cudaLimit limit) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetLimit(pValue, limit) @@ -62,7 +63,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetLimit(size_t* pValue, cyruntime.cudaLim {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cyruntime.cudaChannelFormatDesc* fmtDesc, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) @@ -71,7 +72,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidt {{if 'cudaDeviceGetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetCacheConfig(cyruntime.cudaFuncCache* pCacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetCacheConfig(pCacheConfig) @@ -80,7 +81,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetCacheConfig(cyruntime.cudaFuncCache* pC {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) @@ -89,7 +90,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, {{if 'cudaDeviceSetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetCacheConfig(cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetCacheConfig(cacheConfig) @@ -98,7 +99,7 @@ cdef cyruntime.cudaError_t _cudaDeviceSetCacheConfig(cyruntime.cudaFuncCache cac {{if 'cudaDeviceGetByPCIBusId' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetByPCIBusId(device, pciBusId) @@ -107,7 +108,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pci {{if 'cudaDeviceGetPCIBusId' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetPCIBusId(pciBusId, length, device) @@ -116,7 +117,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, in {{if 'cudaIpcGetEventHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcGetEventHandle(cyruntime.cudaIpcEventHandle_t* handle, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcGetEventHandle(handle, event) @@ -125,7 +126,7 @@ cdef cyruntime.cudaError_t _cudaIpcGetEventHandle(cyruntime.cudaIpcEventHandle_t {{if 'cudaIpcOpenEventHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcOpenEventHandle(cyruntime.cudaEvent_t* event, cyruntime.cudaIpcEventHandle_t handle) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcOpenEventHandle(event, handle) @@ -134,7 +135,7 @@ cdef cyruntime.cudaError_t _cudaIpcOpenEventHandle(cyruntime.cudaEvent_t* event, {{if 'cudaIpcGetMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcGetMemHandle(cyruntime.cudaIpcMemHandle_t* handle, void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcGetMemHandle(handle, devPtr) @@ -143,7 +144,7 @@ cdef cyruntime.cudaError_t _cudaIpcGetMemHandle(cyruntime.cudaIpcMemHandle_t* ha {{if 'cudaIpcOpenMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cyruntime.cudaIpcMemHandle_t handle, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcOpenMemHandle(devPtr, handle, flags) @@ -152,7 +153,7 @@ cdef cyruntime.cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cyruntime.cudaIp {{if 'cudaIpcCloseMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaIpcCloseMemHandle(devPtr) @@ -161,7 +162,7 @@ cdef cyruntime.cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cyruntim {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cyruntime.cudaFlushGPUDirectRDMAWritesTarget target, cyruntime.cudaFlushGPUDirectRDMAWritesScope scope) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceFlushGPUDirectRDMAWrites(target, scope) @@ -170,7 +171,7 @@ cdef cyruntime.cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cyruntime.cudaFlu {{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cyruntime.cudaAsyncCallback callbackFunc, void* userData, cyruntime.cudaAsyncCallbackHandle_t* callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) @@ -179,7 +180,7 @@ cdef cyruntime.cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cyru {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cyruntime.cudaAsyncCallbackHandle_t callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceUnregisterAsyncNotification(device, callback) @@ -188,7 +189,7 @@ cdef cyruntime.cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cy {{if 'cudaDeviceGetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetSharedMemConfig(cyruntime.cudaSharedMemConfig* pConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetSharedMemConfig(pConfig) @@ -197,7 +198,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetSharedMemConfig(cyruntime.cudaSharedMem {{if 'cudaDeviceSetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetSharedMemConfig(cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetSharedMemConfig(config) @@ -206,7 +207,7 @@ cdef cyruntime.cudaError_t _cudaDeviceSetSharedMemConfig(cyruntime.cudaSharedMem {{if 'cudaGetLastError' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetLastError() @@ -215,7 +216,7 @@ cdef cyruntime.cudaError_t _cudaGetLastError() except ?cyruntime.cudaErrorCallRe {{if 'cudaPeekAtLastError' in found_functions}} -cdef cyruntime.cudaError_t _cudaPeekAtLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaPeekAtLastError() @@ -224,7 +225,7 @@ cdef cyruntime.cudaError_t _cudaPeekAtLastError() except ?cyruntime.cudaErrorCal {{if 'cudaGetErrorName' in found_functions}} -cdef const char* _cudaGetErrorName(cyruntime.cudaError_t error) except ?NULL nogil: +cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetErrorName(error) @@ -233,7 +234,7 @@ cdef const char* _cudaGetErrorName(cyruntime.cudaError_t error) except ?NULL nog {{if 'cudaGetErrorString' in found_functions}} -cdef const char* _cudaGetErrorString(cyruntime.cudaError_t error) except ?NULL nogil: +cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetErrorString(error) @@ -242,7 +243,7 @@ cdef const char* _cudaGetErrorString(cyruntime.cudaError_t error) except ?NULL n {{if 'cudaGetDeviceCount' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceCount(int* count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDeviceCount(count) @@ -251,7 +252,7 @@ cdef cyruntime.cudaError_t _cudaGetDeviceCount(int* count) except ?cyruntime.cud {{if 'cudaGetDeviceProperties_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceProperties_v2(cyruntime.cudaDeviceProp* prop, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDeviceProperties_v2(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDeviceProperties_v2(prop, device) @@ -260,7 +261,7 @@ cdef cyruntime.cudaError_t _cudaGetDeviceProperties_v2(cyruntime.cudaDeviceProp* {{if 'cudaDeviceGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetAttribute(int* value, cyruntime.cudaDeviceAttr attr, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetAttribute(value, attr, device) @@ -269,7 +270,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetAttribute(int* value, cyruntime.cudaDev {{if 'cudaDeviceGetDefaultMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetDefaultMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetDefaultMemPool(memPool, device) @@ -278,7 +279,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetDefaultMemPool(cyruntime.cudaMemPool_t* {{if 'cudaDeviceSetMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetMemPool(int device, cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetMemPool(device, memPool) @@ -287,7 +288,7 @@ cdef cyruntime.cudaError_t _cudaDeviceSetMemPool(int device, cyruntime.cudaMemPo {{if 'cudaDeviceGetMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetMemPool(memPool, device) @@ -296,7 +297,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetMemPool(cyruntime.cudaMemPool_t* memPoo {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) @@ -305,7 +306,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttr {{if 'cudaDeviceGetP2PAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetP2PAttribute(int* value, cyruntime.cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) @@ -314,7 +315,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetP2PAttribute(int* value, cyruntime.cuda {{if 'cudaChooseDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaChooseDevice(int* device, const cyruntime.cudaDeviceProp* prop) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaChooseDevice(device, prop) @@ -323,7 +324,7 @@ cdef cyruntime.cudaError_t _cudaChooseDevice(int* device, const cyruntime.cudaDe {{if 'cudaInitDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaInitDevice(device, deviceFlags, flags) @@ -332,7 +333,7 @@ cdef cyruntime.cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, {{if 'cudaSetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaSetDevice(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaSetDevice(device) @@ -341,7 +342,7 @@ cdef cyruntime.cudaError_t _cudaSetDevice(int device) except ?cyruntime.cudaErro {{if 'cudaGetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDevice(int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDevice(device) @@ -350,7 +351,7 @@ cdef cyruntime.cudaError_t _cudaGetDevice(int* device) except ?cyruntime.cudaErr {{if 'cudaSetDeviceFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaSetDeviceFlags(flags) @@ -359,7 +360,7 @@ cdef cyruntime.cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cyrun {{if 'cudaGetDeviceFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDeviceFlags(flags) @@ -368,7 +369,7 @@ cdef cyruntime.cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cyru {{if 'cudaStreamCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreate(cyruntime.cudaStream_t* pStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamCreate(pStream) @@ -377,7 +378,7 @@ cdef cyruntime.cudaError_t _cudaStreamCreate(cyruntime.cudaStream_t* pStream) ex {{if 'cudaStreamCreateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreateWithFlags(cyruntime.cudaStream_t* pStream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamCreateWithFlags(pStream, flags) @@ -386,7 +387,7 @@ cdef cyruntime.cudaError_t _cudaStreamCreateWithFlags(cyruntime.cudaStream_t* pS {{if 'cudaStreamCreateWithPriority' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreateWithPriority(cyruntime.cudaStream_t* pStream, unsigned int flags, int priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamCreateWithPriority(pStream, flags, priority) @@ -395,7 +396,7 @@ cdef cyruntime.cudaError_t _cudaStreamCreateWithPriority(cyruntime.cudaStream_t* {{if 'cudaStreamGetPriority' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetPriority(cyruntime.cudaStream_t hStream, int* priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetPriority(hStream, priority) @@ -404,7 +405,7 @@ cdef cyruntime.cudaError_t _cudaStreamGetPriority(cyruntime.cudaStream_t hStream {{if 'cudaStreamGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetFlags(cyruntime.cudaStream_t hStream, unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetFlags(hStream, flags) @@ -413,7 +414,7 @@ cdef cyruntime.cudaError_t _cudaStreamGetFlags(cyruntime.cudaStream_t hStream, u {{if 'cudaStreamGetId' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetId(cyruntime.cudaStream_t hStream, unsigned long long* streamId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetId(hStream, streamId) @@ -422,7 +423,7 @@ cdef cyruntime.cudaError_t _cudaStreamGetId(cyruntime.cudaStream_t hStream, unsi {{if 'cudaStreamGetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetDevice(cyruntime.cudaStream_t hStream, int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetDevice(hStream, device) @@ -431,7 +432,7 @@ cdef cyruntime.cudaError_t _cudaStreamGetDevice(cyruntime.cudaStream_t hStream, {{if 'cudaCtxResetPersistingL2Cache' in found_functions}} -cdef cyruntime.cudaError_t _cudaCtxResetPersistingL2Cache() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaCtxResetPersistingL2Cache() @@ -440,7 +441,7 @@ cdef cyruntime.cudaError_t _cudaCtxResetPersistingL2Cache() except ?cyruntime.cu {{if 'cudaStreamCopyAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCopyAttributes(cyruntime.cudaStream_t dst, cyruntime.cudaStream_t src) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamCopyAttributes(dst, src) @@ -449,7 +450,7 @@ cdef cyruntime.cudaError_t _cudaStreamCopyAttributes(cyruntime.cudaStream_t dst, {{if 'cudaStreamGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, cyruntime.cudaStreamAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetAttribute(hStream, attr, value_out) @@ -458,7 +459,7 @@ cdef cyruntime.cudaError_t _cudaStreamGetAttribute(cyruntime.cudaStream_t hStrea {{if 'cudaStreamSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamSetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, const cyruntime.cudaStreamAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamSetAttribute(hStream, attr, value) @@ -467,7 +468,7 @@ cdef cyruntime.cudaError_t _cudaStreamSetAttribute(cyruntime.cudaStream_t hStrea {{if 'cudaStreamDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamDestroy(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamDestroy(stream) @@ -476,7 +477,7 @@ cdef cyruntime.cudaError_t _cudaStreamDestroy(cyruntime.cudaStream_t stream) exc {{if 'cudaStreamWaitEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamWaitEvent(cyruntime.cudaStream_t stream, cyruntime.cudaEvent_t event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamWaitEvent(stream, event, flags) @@ -485,7 +486,7 @@ cdef cyruntime.cudaError_t _cudaStreamWaitEvent(cyruntime.cudaStream_t stream, c {{if 'cudaStreamAddCallback' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamAddCallback(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamAddCallback(stream, callback, userData, flags) @@ -494,7 +495,7 @@ cdef cyruntime.cudaError_t _cudaStreamAddCallback(cyruntime.cudaStream_t stream, {{if 'cudaStreamSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamSynchronize(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamSynchronize(stream) @@ -503,7 +504,7 @@ cdef cyruntime.cudaError_t _cudaStreamSynchronize(cyruntime.cudaStream_t stream) {{if 'cudaStreamQuery' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamQuery(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamQuery(stream) @@ -512,7 +513,7 @@ cdef cyruntime.cudaError_t _cudaStreamQuery(cyruntime.cudaStream_t stream) excep {{if 'cudaStreamAttachMemAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamAttachMemAsync(cyruntime.cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamAttachMemAsync(stream, devPtr, length, flags) @@ -521,7 +522,7 @@ cdef cyruntime.cudaError_t _cudaStreamAttachMemAsync(cyruntime.cudaStream_t stre {{if 'cudaStreamBeginCapture' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamBeginCapture(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamBeginCapture(stream, mode) @@ -530,7 +531,7 @@ cdef cyruntime.cudaError_t _cudaStreamBeginCapture(cyruntime.cudaStream_t stream {{if 'cudaStreamBeginCaptureToGraph' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamBeginCaptureToGraph(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) @@ -539,7 +540,7 @@ cdef cyruntime.cudaError_t _cudaStreamBeginCaptureToGraph(cyruntime.cudaStream_t {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} -cdef cyruntime.cudaError_t _cudaThreadExchangeStreamCaptureMode(cyruntime.cudaStreamCaptureMode* mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaThreadExchangeStreamCaptureMode(mode) @@ -548,7 +549,7 @@ cdef cyruntime.cudaError_t _cudaThreadExchangeStreamCaptureMode(cyruntime.cudaSt {{if 'cudaStreamEndCapture' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamEndCapture(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamEndCapture(stream, pGraph) @@ -557,7 +558,7 @@ cdef cyruntime.cudaError_t _cudaStreamEndCapture(cyruntime.cudaStream_t stream, {{if 'cudaStreamIsCapturing' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamIsCapturing(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* pCaptureStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamIsCapturing(stream, pCaptureStatus) @@ -566,7 +567,7 @@ cdef cyruntime.cudaError_t _cudaStreamIsCapturing(cyruntime.cudaStream_t stream, {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v2(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef 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) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetCaptureInfo_v2(stream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out) @@ -575,7 +576,7 @@ cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v2(cyruntime.cudaStream_t s {{if 'cudaStreamGetCaptureInfo_v3' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v3(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, const cyruntime.cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamGetCaptureInfo_v3(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) @@ -584,7 +585,7 @@ cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v3(cyruntime.cudaStream_t s {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamUpdateCaptureDependencies(stream, dependencies, numDependencies, flags) @@ -593,7 +594,7 @@ cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies(cyruntime.cudaSt {{if 'cudaStreamUpdateCaptureDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies_v2(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaStreamUpdateCaptureDependencies_v2(stream, dependencies, dependencyData, numDependencies, flags) @@ -602,7 +603,7 @@ cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies_v2(cyruntime.cud {{if 'cudaEventCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventCreate(cyruntime.cudaEvent_t* event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventCreate(event) @@ -611,7 +612,7 @@ cdef cyruntime.cudaError_t _cudaEventCreate(cyruntime.cudaEvent_t* event) except {{if 'cudaEventCreateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventCreateWithFlags(cyruntime.cudaEvent_t* event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventCreateWithFlags(event, flags) @@ -620,7 +621,7 @@ cdef cyruntime.cudaError_t _cudaEventCreateWithFlags(cyruntime.cudaEvent_t* even {{if 'cudaEventRecord' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventRecord(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventRecord(event, stream) @@ -629,7 +630,7 @@ cdef cyruntime.cudaError_t _cudaEventRecord(cyruntime.cudaEvent_t event, cyrunti {{if 'cudaEventRecordWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventRecordWithFlags(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventRecordWithFlags(event, stream, flags) @@ -638,7 +639,7 @@ cdef cyruntime.cudaError_t _cudaEventRecordWithFlags(cyruntime.cudaEvent_t event {{if 'cudaEventQuery' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventQuery(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventQuery(event) @@ -647,7 +648,7 @@ cdef cyruntime.cudaError_t _cudaEventQuery(cyruntime.cudaEvent_t event) except ? {{if 'cudaEventSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventSynchronize(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventSynchronize(event) @@ -656,7 +657,7 @@ cdef cyruntime.cudaError_t _cudaEventSynchronize(cyruntime.cudaEvent_t event) ex {{if 'cudaEventDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventDestroy(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventDestroy(event) @@ -665,7 +666,7 @@ cdef cyruntime.cudaError_t _cudaEventDestroy(cyruntime.cudaEvent_t event) except {{if 'cudaEventElapsedTime' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventElapsedTime(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventElapsedTime(ms, start, end) @@ -674,7 +675,7 @@ cdef cyruntime.cudaError_t _cudaEventElapsedTime(float* ms, cyruntime.cudaEvent_ {{if 'cudaEventElapsedTime_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventElapsedTime_v2(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaEventElapsedTime_v2(ms, start, end) @@ -683,7 +684,7 @@ cdef cyruntime.cudaError_t _cudaEventElapsedTime_v2(float* ms, cyruntime.cudaEve {{if 'cudaImportExternalMemory' in found_functions}} -cdef cyruntime.cudaError_t _cudaImportExternalMemory(cyruntime.cudaExternalMemory_t* extMem_out, const cyruntime.cudaExternalMemoryHandleDesc* memHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaImportExternalMemory(extMem_out, memHandleDesc) @@ -692,7 +693,7 @@ cdef cyruntime.cudaError_t _cudaImportExternalMemory(cyruntime.cudaExternalMemor {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} -cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryBufferDesc* bufferDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) @@ -701,7 +702,7 @@ cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cyr {{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmap, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) @@ -710,7 +711,7 @@ cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cyruntime. {{if 'cudaDestroyExternalMemory' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyExternalMemory(cyruntime.cudaExternalMemory_t extMem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDestroyExternalMemory(extMem) @@ -719,7 +720,7 @@ cdef cyruntime.cudaError_t _cudaDestroyExternalMemory(cyruntime.cudaExternalMemo {{if 'cudaImportExternalSemaphore' in found_functions}} -cdef cyruntime.cudaError_t _cudaImportExternalSemaphore(cyruntime.cudaExternalSemaphore_t* extSem_out, const cyruntime.cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaImportExternalSemaphore(extSem_out, semHandleDesc) @@ -728,7 +729,7 @@ cdef cyruntime.cudaError_t _cudaImportExternalSemaphore(cyruntime.cudaExternalSe {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaSignalExternalSemaphoresAsync_v2(extSemArray, paramsArray, numExtSems, stream) @@ -737,7 +738,7 @@ cdef cyruntime.cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cyruntime {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaWaitExternalSemaphoresAsync_v2(extSemArray, paramsArray, numExtSems, stream) @@ -746,7 +747,7 @@ cdef cyruntime.cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cyruntime.c {{if 'cudaDestroyExternalSemaphore' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyExternalSemaphore(cyruntime.cudaExternalSemaphore_t extSem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDestroyExternalSemaphore(extSem) @@ -755,7 +756,7 @@ cdef cyruntime.cudaError_t _cudaDestroyExternalSemaphore(cyruntime.cudaExternalS {{if 'cudaFuncSetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetCacheConfig(const void* func, cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFuncSetCacheConfig(func, cacheConfig) @@ -764,7 +765,7 @@ cdef cyruntime.cudaError_t _cudaFuncSetCacheConfig(const void* func, cyruntime.c {{if 'cudaFuncGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncGetAttributes(cyruntime.cudaFuncAttributes* attr, const void* func) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFuncGetAttributes(attr, func) @@ -773,7 +774,7 @@ cdef cyruntime.cudaError_t _cudaFuncGetAttributes(cyruntime.cudaFuncAttributes* {{if 'cudaFuncSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetAttribute(const void* func, cyruntime.cudaFuncAttribute attr, int value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFuncSetAttribute(func, attr, value) @@ -782,7 +783,7 @@ cdef cyruntime.cudaError_t _cudaFuncSetAttribute(const void* func, cyruntime.cud {{if 'cudaLaunchHostFunc' in found_functions}} -cdef cyruntime.cudaError_t _cudaLaunchHostFunc(cyruntime.cudaStream_t stream, cyruntime.cudaHostFn_t fn, void* userData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLaunchHostFunc(stream, fn, userData) @@ -791,7 +792,7 @@ cdef cyruntime.cudaError_t _cudaLaunchHostFunc(cyruntime.cudaStream_t stream, cy {{if 'cudaFuncSetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFuncSetSharedMemConfig(func, config) @@ -800,7 +801,7 @@ cdef cyruntime.cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cyrunti {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) @@ -809,7 +810,7 @@ cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* n {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) @@ -818,7 +819,7 @@ cdef cyruntime.cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dy {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) @@ -827,7 +828,7 @@ cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFla {{if 'cudaMallocManaged' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocManaged(devPtr, size, flags) @@ -836,7 +837,7 @@ cdef cyruntime.cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsign {{if 'cudaMalloc' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMalloc(devPtr, size) @@ -845,7 +846,7 @@ cdef cyruntime.cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cyrun {{if 'cudaMallocHost' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocHost(ptr, size) @@ -854,7 +855,7 @@ cdef cyruntime.cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cyru {{if 'cudaMallocPitch' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocPitch(devPtr, pitch, width, height) @@ -863,7 +864,7 @@ cdef cyruntime.cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t {{if 'cudaMallocArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocArray(array, desc, width, height, flags) @@ -872,7 +873,7 @@ cdef cyruntime.cudaError_t _cudaMallocArray(cyruntime.cudaArray_t* array, const {{if 'cudaFree' in found_functions}} -cdef cyruntime.cudaError_t _cudaFree(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFree(devPtr) @@ -881,7 +882,7 @@ cdef cyruntime.cudaError_t _cudaFree(void* devPtr) except ?cyruntime.cudaErrorCa {{if 'cudaFreeHost' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeHost(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFreeHost(ptr) @@ -890,7 +891,7 @@ cdef cyruntime.cudaError_t _cudaFreeHost(void* ptr) except ?cyruntime.cudaErrorC {{if 'cudaFreeArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeArray(cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFreeArray(array) @@ -899,7 +900,7 @@ cdef cyruntime.cudaError_t _cudaFreeArray(cyruntime.cudaArray_t array) except ?c {{if 'cudaFreeMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeMipmappedArray(cyruntime.cudaMipmappedArray_t mipmappedArray) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFreeMipmappedArray(mipmappedArray) @@ -908,7 +909,7 @@ cdef cyruntime.cudaError_t _cudaFreeMipmappedArray(cyruntime.cudaMipmappedArray_ {{if 'cudaHostAlloc' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostAlloc(pHost, size, flags) @@ -917,7 +918,7 @@ cdef cyruntime.cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned in {{if 'cudaHostRegister' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostRegister(ptr, size, flags) @@ -926,7 +927,7 @@ cdef cyruntime.cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned in {{if 'cudaHostUnregister' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostUnregister(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostUnregister(ptr) @@ -935,7 +936,7 @@ cdef cyruntime.cudaError_t _cudaHostUnregister(void* ptr) except ?cyruntime.cuda {{if 'cudaHostGetDevicePointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostGetDevicePointer(pDevice, pHost, flags) @@ -944,7 +945,7 @@ cdef cyruntime.cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost {{if 'cudaHostGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaHostGetFlags(pFlags, pHost) @@ -953,7 +954,7 @@ cdef cyruntime.cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) {{if 'cudaMalloc3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc3D(cyruntime.cudaPitchedPtr* pitchedDevPtr, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMalloc3D(pitchedDevPtr, extent) @@ -962,7 +963,7 @@ cdef cyruntime.cudaError_t _cudaMalloc3D(cyruntime.cudaPitchedPtr* pitchedDevPtr {{if 'cudaMalloc3DArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc3DArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMalloc3DArray(array, desc, extent, flags) @@ -971,7 +972,7 @@ cdef cyruntime.cudaError_t _cudaMalloc3DArray(cyruntime.cudaArray_t* array, cons {{if 'cudaMallocMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) @@ -980,7 +981,7 @@ cdef cyruntime.cudaError_t _cudaMallocMipmappedArray(cyruntime.cudaMipmappedArra {{if 'cudaGetMipmappedArrayLevel' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetMipmappedArrayLevel(cyruntime.cudaArray_t* levelArray, cyruntime.cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) @@ -989,7 +990,7 @@ cdef cyruntime.cudaError_t _cudaGetMipmappedArrayLevel(cyruntime.cudaArray_t* le {{if 'cudaMemcpy3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3D(const cyruntime.cudaMemcpy3DParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3D(p) @@ -998,7 +999,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy3D(const cyruntime.cudaMemcpy3DParms* p) e {{if 'cudaMemcpy3DPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DPeer(const cyruntime.cudaMemcpy3DPeerParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3DPeer(p) @@ -1007,7 +1008,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy3DPeer(const cyruntime.cudaMemcpy3DPeerPar {{if 'cudaMemcpy3DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DAsync(const cyruntime.cudaMemcpy3DParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3DAsync(p, stream) @@ -1016,7 +1017,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy3DAsync(const cyruntime.cudaMemcpy3DParms* {{if 'cudaMemcpy3DPeerAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DPeerAsync(const cyruntime.cudaMemcpy3DPeerParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3DPeerAsync(p, stream) @@ -1025,7 +1026,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy3DPeerAsync(const cyruntime.cudaMemcpy3DPe {{if 'cudaMemGetInfo' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemGetInfo(free, total) @@ -1034,7 +1035,7 @@ cdef cyruntime.cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ? {{if 'cudaArrayGetInfo' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetInfo(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent* extent, unsigned int* flags, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaArrayGetInfo(desc, extent, flags, array) @@ -1043,7 +1044,7 @@ cdef cyruntime.cudaError_t _cudaArrayGetInfo(cyruntime.cudaChannelFormatDesc* de {{if 'cudaArrayGetPlane' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetPlane(cyruntime.cudaArray_t* pPlaneArray, cyruntime.cudaArray_t hArray, unsigned int planeIdx) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) @@ -1052,7 +1053,7 @@ cdef cyruntime.cudaError_t _cudaArrayGetPlane(cyruntime.cudaArray_t* pPlaneArray {{if 'cudaArrayGetMemoryRequirements' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaArray_t array, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaArrayGetMemoryRequirements(memoryRequirements, array, device) @@ -1061,7 +1062,7 @@ cdef cyruntime.cudaError_t _cudaArrayGetMemoryRequirements(cyruntime.cudaArrayMe {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} -cdef cyruntime.cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaMipmappedArray_t mipmap, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) @@ -1070,7 +1071,7 @@ cdef cyruntime.cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cyruntime.cu {{if 'cudaArrayGetSparseProperties' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaArrayGetSparseProperties(sparseProperties, array) @@ -1079,7 +1080,7 @@ cdef cyruntime.cudaError_t _cudaArrayGetSparseProperties(cyruntime.cudaArraySpar {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} -cdef cyruntime.cudaError_t _cudaMipmappedArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaMipmappedArray_t mipmap) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) @@ -1088,7 +1089,7 @@ cdef cyruntime.cudaError_t _cudaMipmappedArrayGetSparseProperties(cyruntime.cuda {{if 'cudaMemcpy' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy(dst, src, count, kind) @@ -1097,7 +1098,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, {{if 'cudaMemcpyPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) @@ -1106,7 +1107,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* {{if 'cudaMemcpy2D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) @@ -1115,7 +1116,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* s {{if 'cudaMemcpy2DToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) @@ -1124,7 +1125,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy2DToArray(cyruntime.cudaArray_t dst, size_ {{if 'cudaMemcpy2DFromArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) @@ -1133,7 +1134,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cyru {{if 'cudaMemcpy2DArrayToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) @@ -1142,7 +1143,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy2DArrayToArray(cyruntime.cudaArray_t dst, {{if 'cudaMemcpyAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyAsync(dst, src, count, kind, stream) @@ -1151,7 +1152,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t c {{if 'cudaMemcpyPeerAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) @@ -1160,7 +1161,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const {{if 'cudaMemcpyBatchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, cyruntime.cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, stream) @@ -1169,7 +1170,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyBatchAsync(void** dsts, void** srcs, size_ {{if 'cudaMemcpy3DBatchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cyruntime.cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy3DBatchAsync(numOps, opList, failIdx, flags, stream) @@ -1178,7 +1179,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cyruntime.cuda {{if 'cudaMemcpy2DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) @@ -1187,7 +1188,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const vo {{if 'cudaMemcpy2DToArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) @@ -1196,7 +1197,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy2DToArrayAsync(cyruntime.cudaArray_t dst, {{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) @@ -1205,7 +1206,7 @@ cdef cyruntime.cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, {{if 'cudaMemset' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset(devPtr, value, count) @@ -1214,7 +1215,7 @@ cdef cyruntime.cudaError_t _cudaMemset(void* devPtr, int value, size_t count) ex {{if 'cudaMemset2D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset2D(devPtr, pitch, value, width, height) @@ -1223,7 +1224,7 @@ cdef cyruntime.cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, {{if 'cudaMemset3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset3D(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset3D(pitchedDevPtr, value, extent) @@ -1232,7 +1233,7 @@ cdef cyruntime.cudaError_t _cudaMemset3D(cyruntime.cudaPitchedPtr pitchedDevPtr, {{if 'cudaMemsetAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemsetAsync(devPtr, value, count, stream) @@ -1241,7 +1242,7 @@ cdef cyruntime.cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t coun {{if 'cudaMemset2DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) @@ -1250,7 +1251,7 @@ cdef cyruntime.cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int va {{if 'cudaMemset3DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset3DAsync(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) @@ -1259,7 +1260,7 @@ cdef cyruntime.cudaError_t _cudaMemset3DAsync(cyruntime.cudaPitchedPtr pitchedDe {{if 'cudaMemPrefetchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPrefetchAsync(devPtr, count, dstDevice, stream) @@ -1268,7 +1269,7 @@ cdef cyruntime.cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t coun {{if 'cudaMemPrefetchAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cyruntime.cudaMemLocation location, unsigned int flags, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPrefetchAsync_v2(devPtr, count, location, flags, stream) @@ -1277,7 +1278,7 @@ cdef cyruntime.cudaError_t _cudaMemPrefetchAsync_v2(const void* devPtr, size_t c {{if 'cudaMemAdvise' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemAdvise(devPtr, count, advice, device) @@ -1286,7 +1287,7 @@ cdef cyruntime.cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cyru {{if 'cudaMemAdvise_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, cyruntime.cudaMemLocation location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemAdvise_v2(devPtr, count, advice, location) @@ -1295,7 +1296,7 @@ cdef cyruntime.cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, c {{if 'cudaMemRangeGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cyruntime.cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) @@ -1304,7 +1305,7 @@ cdef cyruntime.cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize {{if 'cudaMemRangeGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cyruntime.cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) @@ -1313,7 +1314,7 @@ cdef cyruntime.cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataS {{if 'cudaMemcpyToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) @@ -1322,7 +1323,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyToArray(cyruntime.cudaArray_t dst, size_t {{if 'cudaMemcpyFromArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyFromArray(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) @@ -1331,7 +1332,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyFromArray(void* dst, cyruntime.cudaArray_c {{if 'cudaMemcpyArrayToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) @@ -1340,7 +1341,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyArrayToArray(cyruntime.cudaArray_t dst, si {{if 'cudaMemcpyToArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) @@ -1349,7 +1350,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyToArrayAsync(cyruntime.cudaArray_t dst, si {{if 'cudaMemcpyFromArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) @@ -1358,7 +1359,7 @@ cdef cyruntime.cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cyruntime.cudaAr {{if 'cudaMallocAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocAsync(devPtr, size, hStream) @@ -1367,7 +1368,7 @@ cdef cyruntime.cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cyruntim {{if 'cudaFreeAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeAsync(void* devPtr, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaFreeAsync(devPtr, hStream) @@ -1376,7 +1377,7 @@ cdef cyruntime.cudaError_t _cudaFreeAsync(void* devPtr, cyruntime.cudaStream_t h {{if 'cudaMemPoolTrimTo' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolTrimTo(cyruntime.cudaMemPool_t memPool, size_t minBytesToKeep) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolTrimTo(memPool, minBytesToKeep) @@ -1385,7 +1386,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolTrimTo(cyruntime.cudaMemPool_t memPool, s {{if 'cudaMemPoolSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolSetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolSetAttribute(memPool, attr, value) @@ -1394,7 +1395,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolSetAttribute(cyruntime.cudaMemPool_t memP {{if 'cudaMemPoolGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolGetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolGetAttribute(memPool, attr, value) @@ -1403,7 +1404,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolGetAttribute(cyruntime.cudaMemPool_t memP {{if 'cudaMemPoolSetAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolSetAccess(cyruntime.cudaMemPool_t memPool, const cyruntime.cudaMemAccessDesc* descList, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolSetAccess(memPool, descList, count) @@ -1412,7 +1413,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolSetAccess(cyruntime.cudaMemPool_t memPool {{if 'cudaMemPoolGetAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolGetAccess(cyruntime.cudaMemAccessFlags* flags, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemLocation* location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolGetAccess(flags, memPool, location) @@ -1421,7 +1422,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolGetAccess(cyruntime.cudaMemAccessFlags* f {{if 'cudaMemPoolCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolCreate(cyruntime.cudaMemPool_t* memPool, const cyruntime.cudaMemPoolProps* poolProps) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolCreate(memPool, poolProps) @@ -1430,7 +1431,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolCreate(cyruntime.cudaMemPool_t* memPool, {{if 'cudaMemPoolDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolDestroy(cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolDestroy(memPool) @@ -1439,7 +1440,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolDestroy(cyruntime.cudaMemPool_t memPool) {{if 'cudaMallocFromPoolAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cyruntime.cudaMemPool_t memPool, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMallocFromPoolAsync(ptr, size, memPool, stream) @@ -1448,7 +1449,7 @@ cdef cyruntime.cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cyr {{if 'cudaMemPoolExportToShareableHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) @@ -1457,7 +1458,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHa {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolImportFromShareableHandle(cyruntime.cudaMemPool_t* memPool, void* shareableHandle, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) @@ -1466,7 +1467,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolImportFromShareableHandle(cyruntime.cudaM {{if 'cudaMemPoolExportPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolExportPointer(cyruntime.cudaMemPoolPtrExportData* exportData, void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolExportPointer(exportData, ptr) @@ -1475,7 +1476,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolExportPointer(cyruntime.cudaMemPoolPtrExp {{if 'cudaMemPoolImportPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolImportPointer(void** ptr, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolPtrExportData* exportData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaMemPoolImportPointer(ptr, memPool, exportData) @@ -1484,7 +1485,7 @@ cdef cyruntime.cudaError_t _cudaMemPoolImportPointer(void** ptr, cyruntime.cudaM {{if 'cudaPointerGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaPointerGetAttributes(cyruntime.cudaPointerAttributes* attributes, const void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaPointerGetAttributes(attributes, ptr) @@ -1493,7 +1494,7 @@ cdef cyruntime.cudaError_t _cudaPointerGetAttributes(cyruntime.cudaPointerAttrib {{if 'cudaDeviceCanAccessPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) @@ -1502,7 +1503,7 @@ cdef cyruntime.cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int devi {{if 'cudaDeviceEnablePeerAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceEnablePeerAccess(peerDevice, flags) @@ -1511,7 +1512,7 @@ cdef cyruntime.cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned {{if 'cudaDeviceDisablePeerAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceDisablePeerAccess(peerDevice) @@ -1520,7 +1521,7 @@ cdef cyruntime.cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ? {{if 'cudaGraphicsUnregisterResource' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsUnregisterResource(cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsUnregisterResource(resource) @@ -1529,7 +1530,7 @@ cdef cyruntime.cudaError_t _cudaGraphicsUnregisterResource(cyruntime.cudaGraphic {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceSetMapFlags(cyruntime.cudaGraphicsResource_t resource, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsResourceSetMapFlags(resource, flags) @@ -1538,7 +1539,7 @@ cdef cyruntime.cudaError_t _cudaGraphicsResourceSetMapFlags(cyruntime.cudaGraphi {{if 'cudaGraphicsMapResources' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsMapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsMapResources(count, resources, stream) @@ -1547,7 +1548,7 @@ cdef cyruntime.cudaError_t _cudaGraphicsMapResources(int count, cyruntime.cudaGr {{if 'cudaGraphicsUnmapResources' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsUnmapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsUnmapResources(count, resources, stream) @@ -1556,7 +1557,7 @@ cdef cyruntime.cudaError_t _cudaGraphicsUnmapResources(int count, cyruntime.cuda {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) @@ -1565,7 +1566,7 @@ cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsSubResourceGetMappedArray(cyruntime.cudaArray_t* array, cyruntime.cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) @@ -1574,7 +1575,7 @@ cdef cyruntime.cudaError_t _cudaGraphicsSubResourceGetMappedArray(cyruntime.cuda {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) @@ -1583,7 +1584,7 @@ cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cyruntim {{if 'cudaGetChannelDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetChannelDesc(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaArray_const_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetChannelDesc(desc, array) @@ -1592,7 +1593,7 @@ cdef cyruntime.cudaError_t _cudaGetChannelDesc(cyruntime.cudaChannelFormatDesc* {{if 'cudaCreateChannelDesc' in found_functions}} @cython.show_performance_hints(False) -cdef cyruntime.cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cyruntime.cudaChannelFormatKind f) except* nogil: +cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaCreateChannelDesc(x, y, z, w, f) @@ -1601,7 +1602,7 @@ cdef cyruntime.cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, {{if 'cudaCreateTextureObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaCreateTextureObject(cyruntime.cudaTextureObject_t* pTexObject, const cyruntime.cudaResourceDesc* pResDesc, const cyruntime.cudaTextureDesc* pTexDesc, const cyruntime.cudaResourceViewDesc* pResViewDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) @@ -1610,7 +1611,7 @@ cdef cyruntime.cudaError_t _cudaCreateTextureObject(cyruntime.cudaTextureObject_ {{if 'cudaDestroyTextureObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyTextureObject(cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDestroyTextureObject(texObject) @@ -1619,7 +1620,7 @@ cdef cyruntime.cudaError_t _cudaDestroyTextureObject(cyruntime.cudaTextureObject {{if 'cudaGetTextureObjectResourceDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetTextureObjectResourceDesc(pResDesc, texObject) @@ -1628,7 +1629,7 @@ cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceDesc(cyruntime.cudaResou {{if 'cudaGetTextureObjectTextureDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectTextureDesc(cyruntime.cudaTextureDesc* pTexDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetTextureObjectTextureDesc(pTexDesc, texObject) @@ -1637,7 +1638,7 @@ cdef cyruntime.cudaError_t _cudaGetTextureObjectTextureDesc(cyruntime.cudaTextur {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceViewDesc(cyruntime.cudaResourceViewDesc* pResViewDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) @@ -1646,7 +1647,7 @@ cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceViewDesc(cyruntime.cudaR {{if 'cudaCreateSurfaceObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaCreateSurfaceObject(cyruntime.cudaSurfaceObject_t* pSurfObject, const cyruntime.cudaResourceDesc* pResDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaCreateSurfaceObject(pSurfObject, pResDesc) @@ -1655,7 +1656,7 @@ cdef cyruntime.cudaError_t _cudaCreateSurfaceObject(cyruntime.cudaSurfaceObject_ {{if 'cudaDestroySurfaceObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroySurfaceObject(cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDestroySurfaceObject(surfObject) @@ -1664,7 +1665,7 @@ cdef cyruntime.cudaError_t _cudaDestroySurfaceObject(cyruntime.cudaSurfaceObject {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetSurfaceObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) @@ -1673,7 +1674,7 @@ cdef cyruntime.cudaError_t _cudaGetSurfaceObjectResourceDesc(cyruntime.cudaResou {{if 'cudaDriverGetVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDriverGetVersion(driverVersion) @@ -1682,7 +1683,7 @@ cdef cyruntime.cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cyr {{if 'cudaRuntimeGetVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaRuntimeGetVersion(runtimeVersion) @@ -1691,7 +1692,7 @@ cdef cyruntime.cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?c {{if 'cudaGraphCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphCreate(cyruntime.cudaGraph_t* pGraph, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphCreate(pGraph, flags) @@ -1700,7 +1701,7 @@ cdef cyruntime.cudaError_t _cudaGraphCreate(cyruntime.cudaGraph_t* pGraph, unsig {{if 'cudaGraphAddKernelNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddKernelNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) @@ -1709,7 +1710,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddKernelNode(cyruntime.cudaGraphNode_t* pG {{if 'cudaGraphKernelNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeGetParams(node, pNodeParams) @@ -1718,7 +1719,7 @@ cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetParams(cyruntime.cudaGraphNode {{if 'cudaGraphKernelNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeSetParams(node, pNodeParams) @@ -1727,7 +1728,7 @@ cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetParams(cyruntime.cudaGraphNode {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeCopyAttributes(cyruntime.cudaGraphNode_t hSrc, cyruntime.cudaGraphNode_t hDst) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeCopyAttributes(hSrc, hDst) @@ -1736,7 +1737,7 @@ cdef cyruntime.cudaError_t _cudaGraphKernelNodeCopyAttributes(cyruntime.cudaGrap {{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, cyruntime.cudaKernelNodeAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) @@ -1745,7 +1746,7 @@ cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetAttribute(cyruntime.cudaGraphN {{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, const cyruntime.cudaKernelNodeAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphKernelNodeSetAttribute(hNode, attr, value) @@ -1754,7 +1755,7 @@ cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetAttribute(cyruntime.cudaGraphN {{if 'cudaGraphAddMemcpyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemcpy3DParms* pCopyParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) @@ -1763,7 +1764,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode(cyruntime.cudaGraphNode_t* pG {{if 'cudaGraphAddMemcpyNode1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode1D(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) @@ -1772,7 +1773,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode1D(cyruntime.cudaGraphNode_t* {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemcpyNodeGetParams(node, pNodeParams) @@ -1781,7 +1782,7 @@ cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeGetParams(cyruntime.cudaGraphNode {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemcpyNodeSetParams(node, pNodeParams) @@ -1790,7 +1791,7 @@ cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams(cyruntime.cudaGraphNode {{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams1D(cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) @@ -1799,7 +1800,7 @@ cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams1D(cyruntime.cudaGraphNo {{if 'cudaGraphAddMemsetNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemsetNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemsetParams* pMemsetParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) @@ -1808,7 +1809,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddMemsetNode(cyruntime.cudaGraphNode_t* pG {{if 'cudaGraphMemsetNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemsetNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemsetNodeGetParams(node, pNodeParams) @@ -1817,7 +1818,7 @@ cdef cyruntime.cudaError_t _cudaGraphMemsetNodeGetParams(cyruntime.cudaGraphNode {{if 'cudaGraphMemsetNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemsetNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemsetNodeSetParams(node, pNodeParams) @@ -1826,7 +1827,7 @@ cdef cyruntime.cudaError_t _cudaGraphMemsetNodeSetParams(cyruntime.cudaGraphNode {{if 'cudaGraphAddHostNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddHostNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) @@ -1835,7 +1836,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddHostNode(cyruntime.cudaGraphNode_t* pGra {{if 'cudaGraphHostNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphHostNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphHostNodeGetParams(node, pNodeParams) @@ -1844,7 +1845,7 @@ cdef cyruntime.cudaError_t _cudaGraphHostNodeGetParams(cyruntime.cudaGraphNode_t {{if 'cudaGraphHostNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphHostNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphHostNodeSetParams(node, pNodeParams) @@ -1853,7 +1854,7 @@ cdef cyruntime.cudaError_t _cudaGraphHostNodeSetParams(cyruntime.cudaGraphNode_t {{if 'cudaGraphAddChildGraphNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddChildGraphNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraph_t childGraph) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) @@ -1862,7 +1863,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddChildGraphNode(cyruntime.cudaGraphNode_t {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphChildGraphNodeGetGraph(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphChildGraphNodeGetGraph(node, pGraph) @@ -1871,7 +1872,7 @@ cdef cyruntime.cudaError_t _cudaGraphChildGraphNodeGetGraph(cyruntime.cudaGraphN {{if 'cudaGraphAddEmptyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEmptyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) @@ -1880,7 +1881,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddEmptyNode(cyruntime.cudaGraphNode_t* pGr {{if 'cudaGraphAddEventRecordNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEventRecordNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) @@ -1889,7 +1890,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddEventRecordNode(cyruntime.cudaGraphNode_ {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphEventRecordNodeGetEvent(node, event_out) @@ -1898,7 +1899,7 @@ cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeGetEvent(cyruntime.cudaGraph {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphEventRecordNodeSetEvent(node, event) @@ -1907,7 +1908,7 @@ cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeSetEvent(cyruntime.cudaGraph {{if 'cudaGraphAddEventWaitNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEventWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) @@ -1916,7 +1917,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddEventWaitNode(cyruntime.cudaGraphNode_t* {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphEventWaitNodeGetEvent(node, event_out) @@ -1925,7 +1926,7 @@ cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeGetEvent(cyruntime.cudaGraphNo {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphEventWaitNodeSetEvent(node, event) @@ -1934,7 +1935,7 @@ cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeSetEvent(cyruntime.cudaGraphNo {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) @@ -1943,7 +1944,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cyruntime.c {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreSignalNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) @@ -1952,7 +1953,7 @@ cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cyrun {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) @@ -1961,7 +1962,7 @@ cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cyrun {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) @@ -1970,7 +1971,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cyruntime.cud {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreWaitNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) @@ -1979,7 +1980,7 @@ cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cyrunti {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) @@ -1988,7 +1989,7 @@ cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cyrunti {{if 'cudaGraphAddMemAllocNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemAllocNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaMemAllocNodeParams* nodeParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) @@ -1997,7 +1998,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddMemAllocNode(cyruntime.cudaGraphNode_t* {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemAllocNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemAllocNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemAllocNodeGetParams(node, params_out) @@ -2006,7 +2007,7 @@ cdef cyruntime.cudaError_t _cudaGraphMemAllocNodeGetParams(cyruntime.cudaGraphNo {{if 'cudaGraphAddMemFreeNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemFreeNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) @@ -2015,7 +2016,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddMemFreeNode(cyruntime.cudaGraphNode_t* p {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemFreeNodeGetParams(cyruntime.cudaGraphNode_t node, void* dptr_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphMemFreeNodeGetParams(node, dptr_out) @@ -2024,7 +2025,7 @@ cdef cyruntime.cudaError_t _cudaGraphMemFreeNodeGetParams(cyruntime.cudaGraphNod {{if 'cudaDeviceGraphMemTrim' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGraphMemTrim(device) @@ -2033,7 +2034,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cyruntime {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceGetGraphMemAttribute(device, attr, value) @@ -2042,7 +2043,7 @@ cdef cyruntime.cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cyruntime {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaDeviceSetGraphMemAttribute(device, attr, value) @@ -2051,7 +2052,7 @@ cdef cyruntime.cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cyruntime {{if 'cudaGraphClone' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphClone(cyruntime.cudaGraph_t* pGraphClone, cyruntime.cudaGraph_t originalGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphClone(pGraphClone, originalGraph) @@ -2060,7 +2061,7 @@ cdef cyruntime.cudaError_t _cudaGraphClone(cyruntime.cudaGraph_t* pGraphClone, c {{if 'cudaGraphNodeFindInClone' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeFindInClone(cyruntime.cudaGraphNode_t* pNode, cyruntime.cudaGraphNode_t originalNode, cyruntime.cudaGraph_t clonedGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) @@ -2069,7 +2070,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeFindInClone(cyruntime.cudaGraphNode_t* {{if 'cudaGraphNodeGetType' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetType(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeType* pType) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetType(node, pType) @@ -2078,7 +2079,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeGetType(cyruntime.cudaGraphNode_t node, {{if 'cudaGraphGetNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* nodes, size_t* numNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphGetNodes(graph, nodes, numNodes) @@ -2087,7 +2088,7 @@ cdef cyruntime.cudaError_t _cudaGraphGetNodes(cyruntime.cudaGraph_t graph, cyrun {{if 'cudaGraphGetRootNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetRootNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) @@ -2096,7 +2097,7 @@ cdef cyruntime.cudaError_t _cudaGraphGetRootNodes(cyruntime.cudaGraph_t graph, c {{if 'cudaGraphGetEdges' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetEdges(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphGetEdges(graph, from_, to, numEdges) @@ -2105,7 +2106,7 @@ cdef cyruntime.cudaError_t _cudaGraphGetEdges(cyruntime.cudaGraph_t graph, cyrun {{if 'cudaGraphGetEdges_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetEdges_v2(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, cyruntime.cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphGetEdges_v2(graph, from_, to, edgeData, numEdges) @@ -2114,7 +2115,7 @@ cdef cyruntime.cudaError_t _cudaGraphGetEdges_v2(cyruntime.cudaGraph_t graph, cy {{if 'cudaGraphNodeGetDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetDependencies(node, pDependencies, pNumDependencies) @@ -2123,7 +2124,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies(cyruntime.cudaGraphNode {{if 'cudaGraphNodeGetDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetDependencies_v2(node, pDependencies, edgeData, pNumDependencies) @@ -2132,7 +2133,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies_v2(cyruntime.cudaGraphN {{if 'cudaGraphNodeGetDependentNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetDependentNodes(node, pDependentNodes, pNumDependentNodes) @@ -2141,7 +2142,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes(cyruntime.cudaGraphNo {{if 'cudaGraphNodeGetDependentNodes_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetDependentNodes_v2(node, pDependentNodes, edgeData, pNumDependentNodes) @@ -2150,7 +2151,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes_v2(cyruntime.cudaGrap {{if 'cudaGraphAddDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddDependencies(graph, from_, to, numDependencies) @@ -2159,7 +2160,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddDependencies(cyruntime.cudaGraph_t graph {{if 'cudaGraphAddDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddDependencies_v2(graph, from_, to, edgeData, numDependencies) @@ -2168,7 +2169,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddDependencies_v2(cyruntime.cudaGraph_t gr {{if 'cudaGraphRemoveDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphRemoveDependencies(graph, from_, to, numDependencies) @@ -2177,7 +2178,7 @@ cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies(cyruntime.cudaGraph_t gr {{if 'cudaGraphRemoveDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphRemoveDependencies_v2(graph, from_, to, edgeData, numDependencies) @@ -2186,7 +2187,7 @@ cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies_v2(cyruntime.cudaGraph_t {{if 'cudaGraphDestroyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDestroyNode(cyruntime.cudaGraphNode_t node) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphDestroyNode(node) @@ -2195,7 +2196,7 @@ cdef cyruntime.cudaError_t _cudaGraphDestroyNode(cyruntime.cudaGraphNode_t node) {{if 'cudaGraphInstantiate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiate(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphInstantiate(pGraphExec, graph, flags) @@ -2204,7 +2205,7 @@ cdef cyruntime.cudaError_t _cudaGraphInstantiate(cyruntime.cudaGraphExec_t* pGra {{if 'cudaGraphInstantiateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiateWithFlags(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) @@ -2213,7 +2214,7 @@ cdef cyruntime.cudaError_t _cudaGraphInstantiateWithFlags(cyruntime.cudaGraphExe {{if 'cudaGraphInstantiateWithParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiateWithParams(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, cyruntime.cudaGraphInstantiateParams* instantiateParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) @@ -2222,7 +2223,7 @@ cdef cyruntime.cudaError_t _cudaGraphInstantiateWithParams(cyruntime.cudaGraphEx {{if 'cudaGraphExecGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecGetFlags(cyruntime.cudaGraphExec_t graphExec, unsigned long long* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecGetFlags(graphExec, flags) @@ -2231,7 +2232,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecGetFlags(cyruntime.cudaGraphExec_t grap {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecKernelNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) @@ -2240,7 +2241,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecKernelNodeSetParams(cyruntime.cudaGraph {{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) @@ -2249,7 +2250,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams(cyruntime.cudaGraph {{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) @@ -2258,7 +2259,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cyruntime.cudaGra {{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemsetNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) @@ -2267,7 +2268,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecMemsetNodeSetParams(cyruntime.cudaGraph {{if 'cudaGraphExecHostNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecHostNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) @@ -2276,7 +2277,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecHostNodeSetParams(cyruntime.cudaGraphEx {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecChildGraphNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t childGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) @@ -2285,7 +2286,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecChildGraphNodeSetParams(cyruntime.cudaG {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) @@ -2294,7 +2295,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cyruntime.cudaG {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) @@ -2303,7 +2304,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cyruntime.cudaGra {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) @@ -2312,7 +2313,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(c {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) @@ -2321,7 +2322,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyr {{if 'cudaGraphNodeSetEnabled' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeSetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) @@ -2330,7 +2331,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeSetEnabled(cyruntime.cudaGraphExec_t hG {{if 'cudaGraphNodeGetEnabled' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) @@ -2339,7 +2340,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeGetEnabled(cyruntime.cudaGraphExec_t hG {{if 'cudaGraphExecUpdate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecUpdate(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraph_t hGraph, cyruntime.cudaGraphExecUpdateResultInfo* resultInfo) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) @@ -2348,7 +2349,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecUpdate(cyruntime.cudaGraphExec_t hGraph {{if 'cudaGraphUpload' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphUpload(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphUpload(graphExec, stream) @@ -2357,7 +2358,7 @@ cdef cyruntime.cudaError_t _cudaGraphUpload(cyruntime.cudaGraphExec_t graphExec, {{if 'cudaGraphLaunch' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphLaunch(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphLaunch(graphExec, stream) @@ -2366,7 +2367,7 @@ cdef cyruntime.cudaError_t _cudaGraphLaunch(cyruntime.cudaGraphExec_t graphExec, {{if 'cudaGraphExecDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecDestroy(cyruntime.cudaGraphExec_t graphExec) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecDestroy(graphExec) @@ -2375,7 +2376,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecDestroy(cyruntime.cudaGraphExec_t graph {{if 'cudaGraphDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDestroy(cyruntime.cudaGraph_t graph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphDestroy(graph) @@ -2384,7 +2385,7 @@ cdef cyruntime.cudaError_t _cudaGraphDestroy(cyruntime.cudaGraph_t graph) except {{if 'cudaGraphDebugDotPrint' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDebugDotPrint(cyruntime.cudaGraph_t graph, const char* path, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphDebugDotPrint(graph, path, flags) @@ -2393,7 +2394,7 @@ cdef cyruntime.cudaError_t _cudaGraphDebugDotPrint(cyruntime.cudaGraph_t graph, {{if 'cudaUserObjectCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectCreate(cyruntime.cudaUserObject_t* object_out, void* ptr, cyruntime.cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) @@ -2402,7 +2403,7 @@ cdef cyruntime.cudaError_t _cudaUserObjectCreate(cyruntime.cudaUserObject_t* obj {{if 'cudaUserObjectRetain' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectRetain(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaUserObjectRetain(object, count) @@ -2411,7 +2412,7 @@ cdef cyruntime.cudaError_t _cudaUserObjectRetain(cyruntime.cudaUserObject_t obje {{if 'cudaUserObjectRelease' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectRelease(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaUserObjectRelease(object, count) @@ -2420,7 +2421,7 @@ cdef cyruntime.cudaError_t _cudaUserObjectRelease(cyruntime.cudaUserObject_t obj {{if 'cudaGraphRetainUserObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRetainUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphRetainUserObject(graph, object, count, flags) @@ -2429,7 +2430,7 @@ cdef cyruntime.cudaError_t _cudaGraphRetainUserObject(cyruntime.cudaGraph_t grap {{if 'cudaGraphReleaseUserObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphReleaseUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphReleaseUserObject(graph, object, count) @@ -2438,7 +2439,7 @@ cdef cyruntime.cudaError_t _cudaGraphReleaseUserObject(cyruntime.cudaGraph_t gra {{if 'cudaGraphAddNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) @@ -2447,7 +2448,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddNode(cyruntime.cudaGraphNode_t* pGraphNo {{if 'cudaGraphAddNode_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddNode_v2(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphAddNode_v2(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) @@ -2456,7 +2457,7 @@ cdef cyruntime.cudaError_t _cudaGraphAddNode_v2(cyruntime.cudaGraphNode_t* pGrap {{if 'cudaGraphNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeSetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphNodeSetParams(node, nodeParams) @@ -2465,7 +2466,7 @@ cdef cyruntime.cudaError_t _cudaGraphNodeSetParams(cyruntime.cudaGraphNode_t nod {{if 'cudaGraphExecNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecNodeSetParams(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphExecNodeSetParams(graphExec, node, nodeParams) @@ -2474,7 +2475,7 @@ cdef cyruntime.cudaError_t _cudaGraphExecNodeSetParams(cyruntime.cudaGraphExec_t {{if 'cudaGraphConditionalHandleCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphConditionalHandleCreate(cyruntime.cudaGraphConditionalHandle* pHandle_out, cyruntime.cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) @@ -2483,7 +2484,7 @@ cdef cyruntime.cudaError_t _cudaGraphConditionalHandleCreate(cyruntime.cudaGraph {{if 'cudaGetDriverEntryPoint' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) @@ -2492,7 +2493,7 @@ cdef cyruntime.cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** f {{if 'cudaGetDriverEntryPointByVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) @@ -2501,7 +2502,7 @@ cdef cyruntime.cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, {{if 'cudaLibraryLoadData' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryLoadData(cyruntime.cudaLibrary_t* library, const void* code, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) @@ -2510,7 +2511,7 @@ cdef cyruntime.cudaError_t _cudaLibraryLoadData(cyruntime.cudaLibrary_t* library {{if 'cudaLibraryLoadFromFile' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryLoadFromFile(cyruntime.cudaLibrary_t* library, const char* fileName, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.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 bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) @@ -2519,7 +2520,7 @@ cdef cyruntime.cudaError_t _cudaLibraryLoadFromFile(cyruntime.cudaLibrary_t* lib {{if 'cudaLibraryUnload' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryUnload(cyruntime.cudaLibrary_t library) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryUnload(library) @@ -2528,7 +2529,7 @@ cdef cyruntime.cudaError_t _cudaLibraryUnload(cyruntime.cudaLibrary_t library) e {{if 'cudaLibraryGetKernel' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetKernel(cyruntime.cudaKernel_t* pKernel, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryGetKernel(pKernel, library, name) @@ -2537,7 +2538,7 @@ cdef cyruntime.cudaError_t _cudaLibraryGetKernel(cyruntime.cudaKernel_t* pKernel {{if 'cudaLibraryGetGlobal' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryGetGlobal(dptr, numbytes, library, name) @@ -2546,7 +2547,7 @@ cdef cyruntime.cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, {{if 'cudaLibraryGetManaged' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryGetManaged(dptr, numbytes, library, name) @@ -2555,7 +2556,7 @@ cdef cyruntime.cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, {{if 'cudaLibraryGetUnifiedFunction' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cyruntime.cudaLibrary_t library, const char* symbol) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryGetUnifiedFunction(fptr, library, symbol) @@ -2564,7 +2565,7 @@ cdef cyruntime.cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cyruntime {{if 'cudaLibraryGetKernelCount' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryGetKernelCount(count, lib) @@ -2573,7 +2574,7 @@ cdef cyruntime.cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cyrun {{if 'cudaLibraryEnumerateKernels' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryEnumerateKernels(cyruntime.cudaKernel_t* kernels, unsigned int numKernels, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaLibraryEnumerateKernels(kernels, numKernels, lib) @@ -2582,7 +2583,7 @@ cdef cyruntime.cudaError_t _cudaLibraryEnumerateKernels(cyruntime.cudaKernel_t* {{if 'cudaKernelSetAttributeForDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaKernelSetAttributeForDevice(cyruntime.cudaKernel_t kernel, cyruntime.cudaFuncAttribute attr, int value, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaKernelSetAttributeForDevice(kernel, attr, value, device) @@ -2591,7 +2592,7 @@ cdef cyruntime.cudaError_t _cudaKernelSetAttributeForDevice(cyruntime.cudaKernel {{if 'cudaGetExportTable' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetExportTable(const void** ppExportTable, const cyruntime.cudaUUID_t* pExportTableId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetExportTable(ppExportTable, pExportTableId) @@ -2600,7 +2601,7 @@ cdef cyruntime.cudaError_t _cudaGetExportTable(const void** ppExportTable, const {{if 'cudaGetKernel' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetKernel(cyruntime.cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaGetKernel(kernelPtr, entryFuncAddr) @@ -2609,7 +2610,7 @@ cdef cyruntime.cudaError_t _cudaGetKernel(cyruntime.cudaKernel_t* kernelPtr, con {{if 'make_cudaPitchedPtr' in found_functions}} @cython.show_performance_hints(False) -cdef cyruntime.cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil: +cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._make_cudaPitchedPtr(d, p, xsz, ysz) @@ -2618,7 +2619,7 @@ cdef cyruntime.cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz {{if 'make_cudaPos' in found_functions}} @cython.show_performance_hints(False) -cdef cyruntime.cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil: +cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._make_cudaPos(x, y, z) @@ -2627,7 +2628,7 @@ cdef cyruntime.cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil {{if 'make_cudaExtent' in found_functions}} @cython.show_performance_hints(False) -cdef cyruntime.cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil: +cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._make_cudaExtent(w, h, d) @@ -2636,7 +2637,7 @@ cdef cyruntime.cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* {{if 'cudaProfilerStart' in found_functions}} -cdef cyruntime.cudaError_t _cudaProfilerStart() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaProfilerStart() @@ -2645,7 +2646,7 @@ cdef cyruntime.cudaError_t _cudaProfilerStart() except ?cyruntime.cudaErrorCallR {{if 'cudaProfilerStop' in found_functions}} -cdef cyruntime.cudaError_t _cudaProfilerStop() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: cdef bint usePTDS = cudaPythonInit() if usePTDS: return ptds._cudaProfilerStop() diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in index 66c3a8cb3..f46087700 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pxd.in @@ -6,1470 +6,1470 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. cdef extern from "": """ #define CUDA_API_PER_THREAD_DEFAULT_STREAM """ -cimport cuda.bindings.cyruntime as cyruntime +include "../cyruntime_types.pxi" {{if 'cudaDeviceReset' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceReset() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSynchronize() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetLimit' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetLimit(cyruntime.cudaLimit limit, size_t value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetLimit' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetLimit(size_t* pValue, cyruntime.cudaLimit limit) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cyruntime.cudaChannelFormatDesc* fmtDesc, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetCacheConfig(cyruntime.cudaFuncCache* pCacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetCacheConfig(cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetByPCIBusId' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetPCIBusId' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcGetEventHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcGetEventHandle(cyruntime.cudaIpcEventHandle_t* handle, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcOpenEventHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcOpenEventHandle(cyruntime.cudaEvent_t* event, cyruntime.cudaIpcEventHandle_t handle) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcGetMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcGetMemHandle(cyruntime.cudaIpcMemHandle_t* handle, void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcOpenMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cyruntime.cudaIpcMemHandle_t handle, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaIpcCloseMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cyruntime.cudaFlushGPUDirectRDMAWritesTarget target, cyruntime.cudaFlushGPUDirectRDMAWritesScope scope) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cyruntime.cudaAsyncCallback callbackFunc, void* userData, cyruntime.cudaAsyncCallbackHandle_t* callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cyruntime.cudaAsyncCallbackHandle_t callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetSharedMemConfig(cyruntime.cudaSharedMemConfig* pConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetSharedMemConfig(cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetLastError' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaPeekAtLastError' in found_functions}} -cdef cyruntime.cudaError_t _cudaPeekAtLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetErrorName' in found_functions}} -cdef const char* _cudaGetErrorName(cyruntime.cudaError_t error) except ?NULL nogil +cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil {{endif}} {{if 'cudaGetErrorString' in found_functions}} -cdef const char* _cudaGetErrorString(cyruntime.cudaError_t error) except ?NULL nogil +cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil {{endif}} {{if 'cudaGetDeviceCount' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceCount(int* count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDeviceProperties_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceProperties_v2(cyruntime.cudaDeviceProp* prop, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDeviceProperties_v2(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetAttribute(int* value, cyruntime.cudaDeviceAttr attr, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetDefaultMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetDefaultMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetMemPool(int device, cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetP2PAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetP2PAttribute(int* value, cyruntime.cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaChooseDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaChooseDevice(int* device, const cyruntime.cudaDeviceProp* prop) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaInitDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaSetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaSetDevice(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDevice(int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaSetDeviceFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDeviceFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreate(cyruntime.cudaStream_t* pStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamCreateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreateWithFlags(cyruntime.cudaStream_t* pStream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamCreateWithPriority' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreateWithPriority(cyruntime.cudaStream_t* pStream, unsigned int flags, int priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetPriority' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetPriority(cyruntime.cudaStream_t hStream, int* priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetFlags(cyruntime.cudaStream_t hStream, unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetId' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetId(cyruntime.cudaStream_t hStream, unsigned long long* streamId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetDevice(cyruntime.cudaStream_t hStream, int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaCtxResetPersistingL2Cache' in found_functions}} -cdef cyruntime.cudaError_t _cudaCtxResetPersistingL2Cache() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamCopyAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCopyAttributes(cyruntime.cudaStream_t dst, cyruntime.cudaStream_t src) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, cyruntime.cudaStreamAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamSetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, const cyruntime.cudaStreamAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamDestroy(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamWaitEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamWaitEvent(cyruntime.cudaStream_t stream, cyruntime.cudaEvent_t event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamAddCallback' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamAddCallback(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamSynchronize(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamQuery' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamQuery(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamAttachMemAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamAttachMemAsync(cyruntime.cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamBeginCapture' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamBeginCapture(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamBeginCaptureToGraph' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamBeginCaptureToGraph(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.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 {{endif}} {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} -cdef cyruntime.cudaError_t _cudaThreadExchangeStreamCaptureMode(cyruntime.cudaStreamCaptureMode* mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamEndCapture' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamEndCapture(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamIsCapturing' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamIsCapturing(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* pCaptureStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v2(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef 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) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamGetCaptureInfo_v3' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v3(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, const cyruntime.cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cyruntime.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 {{endif}} {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaStreamUpdateCaptureDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies_v2(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cyruntime.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 {{endif}} {{if 'cudaEventCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventCreate(cyruntime.cudaEvent_t* event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventCreateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventCreateWithFlags(cyruntime.cudaEvent_t* event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventRecord' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventRecord(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventRecordWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventRecordWithFlags(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventQuery' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventQuery(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventSynchronize(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventDestroy(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventElapsedTime' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventElapsedTime(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaEventElapsedTime_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventElapsedTime_v2(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaImportExternalMemory' in found_functions}} -cdef cyruntime.cudaError_t _cudaImportExternalMemory(cyruntime.cudaExternalMemory_t* extMem_out, const cyruntime.cudaExternalMemoryHandleDesc* memHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} -cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryBufferDesc* bufferDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmap, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDestroyExternalMemory' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyExternalMemory(cyruntime.cudaExternalMemory_t extMem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaImportExternalSemaphore' in found_functions}} -cdef cyruntime.cudaError_t _cudaImportExternalSemaphore(cyruntime.cudaExternalSemaphore_t* extSem_out, const cyruntime.cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDestroyExternalSemaphore' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyExternalSemaphore(cyruntime.cudaExternalSemaphore_t extSem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFuncSetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetCacheConfig(const void* func, cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFuncGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncGetAttributes(cyruntime.cudaFuncAttributes* attr, const void* func) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFuncSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetAttribute(const void* func, cyruntime.cudaFuncAttribute attr, int value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLaunchHostFunc' in found_functions}} -cdef cyruntime.cudaError_t _cudaLaunchHostFunc(cyruntime.cudaStream_t stream, cyruntime.cudaHostFn_t fn, void* userData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFuncSetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocManaged' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMalloc' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocHost' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocPitch' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFree' in found_functions}} -cdef cyruntime.cudaError_t _cudaFree(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFreeHost' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeHost(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFreeArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeArray(cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFreeMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeMipmappedArray(cyruntime.cudaMipmappedArray_t mipmappedArray) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostAlloc' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostRegister' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostUnregister' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostUnregister(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostGetDevicePointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaHostGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMalloc3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc3D(cyruntime.cudaPitchedPtr* pitchedDevPtr, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMalloc3DArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc3DArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetMipmappedArrayLevel' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetMipmappedArrayLevel(cyruntime.cudaArray_t* levelArray, cyruntime.cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3D(const cyruntime.cudaMemcpy3DParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy3DPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DPeer(const cyruntime.cudaMemcpy3DPeerParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy3DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DAsync(const cyruntime.cudaMemcpy3DParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy3DPeerAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DPeerAsync(const cyruntime.cudaMemcpy3DPeerParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemGetInfo' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaArrayGetInfo' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetInfo(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent* extent, unsigned int* flags, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaArrayGetPlane' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetPlane(cyruntime.cudaArray_t* pPlaneArray, cyruntime.cudaArray_t hArray, unsigned int planeIdx) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaArrayGetMemoryRequirements' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaArray_t array, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} -cdef cyruntime.cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaMipmappedArray_t mipmap, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaArrayGetSparseProperties' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} -cdef cyruntime.cudaError_t _cudaMipmappedArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaMipmappedArray_t mipmap) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpyPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy2D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DFromArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DArrayToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpyPeerAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpyBatchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, cyruntime.cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy3DBatchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cyruntime.cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemcpy2DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DToArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemset' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemset2D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemset3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset3D(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemsetAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemset2DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemset3DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset3DAsync(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPrefetchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPrefetchAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cyruntime.cudaMemLocation location, unsigned int flags, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemAdvise' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemAdvise_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, cyruntime.cudaMemLocation location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemRangeGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cyruntime.cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemRangeGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cyruntime.cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyFromArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyFromArray(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyArrayToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyToArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMemcpyFromArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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 {{endif}} {{if 'cudaMallocAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaFreeAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeAsync(void* devPtr, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolTrimTo' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolTrimTo(cyruntime.cudaMemPool_t memPool, size_t minBytesToKeep) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolSetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolGetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolSetAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolSetAccess(cyruntime.cudaMemPool_t memPool, const cyruntime.cudaMemAccessDesc* descList, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolGetAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolGetAccess(cyruntime.cudaMemAccessFlags* flags, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemLocation* location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolCreate(cyruntime.cudaMemPool_t* memPool, const cyruntime.cudaMemPoolProps* poolProps) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolDestroy(cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMallocFromPoolAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cyruntime.cudaMemPool_t memPool, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolExportToShareableHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolImportFromShareableHandle(cyruntime.cudaMemPool_t* memPool, void* shareableHandle, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolExportPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolExportPointer(cyruntime.cudaMemPoolPtrExportData* exportData, void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaMemPoolImportPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolImportPointer(void** ptr, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolPtrExportData* exportData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaPointerGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaPointerGetAttributes(cyruntime.cudaPointerAttributes* attributes, const void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceCanAccessPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceEnablePeerAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceDisablePeerAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsUnregisterResource' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsUnregisterResource(cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceSetMapFlags(cyruntime.cudaGraphicsResource_t resource, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsMapResources' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsMapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsUnmapResources' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsUnmapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsSubResourceGetMappedArray(cyruntime.cudaArray_t* array, cyruntime.cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetChannelDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetChannelDesc(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaArray_const_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaCreateChannelDesc' in found_functions}} -cdef cyruntime.cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cyruntime.cudaChannelFormatKind f) except* nogil +cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil {{endif}} {{if 'cudaCreateTextureObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaCreateTextureObject(cyruntime.cudaTextureObject_t* pTexObject, const cyruntime.cudaResourceDesc* pResDesc, const cyruntime.cudaTextureDesc* pTexDesc, const cyruntime.cudaResourceViewDesc* pResViewDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDestroyTextureObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyTextureObject(cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetTextureObjectResourceDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetTextureObjectTextureDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectTextureDesc(cyruntime.cudaTextureDesc* pTexDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceViewDesc(cyruntime.cudaResourceViewDesc* pResViewDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaCreateSurfaceObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaCreateSurfaceObject(cyruntime.cudaSurfaceObject_t* pSurfObject, const cyruntime.cudaResourceDesc* pResDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDestroySurfaceObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroySurfaceObject(cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetSurfaceObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDriverGetVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaRuntimeGetVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphCreate(cyruntime.cudaGraph_t* pGraph, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddKernelNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddKernelNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphKernelNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphKernelNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeCopyAttributes(cyruntime.cudaGraphNode_t hSrc, cyruntime.cudaGraphNode_t hDst) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, cyruntime.cudaKernelNodeAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, const cyruntime.cudaKernelNodeAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddMemcpyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemcpy3DParms* pCopyParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphAddMemcpyNode1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode1D(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams1D(cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddMemsetNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemsetNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemsetParams* pMemsetParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphMemsetNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemsetNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemsetNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemsetNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddHostNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddHostNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphHostNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphHostNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphHostNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphHostNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddChildGraphNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddChildGraphNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraph_t childGraph) except ?cyruntime.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 {{endif}} {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphChildGraphNodeGetGraph(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddEmptyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEmptyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddEventRecordNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEventRecordNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.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 {{endif}} {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddEventWaitNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEventWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.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 {{endif}} {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreSignalNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreWaitNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddMemAllocNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemAllocNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaMemAllocNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemAllocNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemAllocNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddMemFreeNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemFreeNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemFreeNodeGetParams(cyruntime.cudaGraphNode_t node, void* dptr_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGraphMemTrim' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphClone' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphClone(cyruntime.cudaGraph_t* pGraphClone, cyruntime.cudaGraph_t originalGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeFindInClone' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeFindInClone(cyruntime.cudaGraphNode_t* pNode, cyruntime.cudaGraphNode_t originalNode, cyruntime.cudaGraph_t clonedGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetType' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetType(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeType* pType) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphGetNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* nodes, size_t* numNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphGetRootNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetRootNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphGetEdges' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetEdges(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphGetEdges_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetEdges_v2(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, cyruntime.cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetDependentNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetDependentNodes_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.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 {{endif}} {{if 'cudaGraphRemoveDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphRemoveDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.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 {{endif}} {{if 'cudaGraphDestroyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDestroyNode(cyruntime.cudaGraphNode_t node) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphInstantiate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiate(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphInstantiateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiateWithFlags(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphInstantiateWithParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiateWithParams(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, cyruntime.cudaGraphInstantiateParams* instantiateParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecGetFlags(cyruntime.cudaGraphExec_t graphExec, unsigned long long* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecKernelNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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 {{endif}} {{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemsetNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecHostNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecHostNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecChildGraphNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t childGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeSetEnabled' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeSetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphNodeGetEnabled' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecUpdate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecUpdate(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraph_t hGraph, cyruntime.cudaGraphExecUpdateResultInfo* resultInfo) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphUpload' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphUpload(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphLaunch' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphLaunch(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecDestroy(cyruntime.cudaGraphExec_t graphExec) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDestroy(cyruntime.cudaGraph_t graph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphDebugDotPrint' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDebugDotPrint(cyruntime.cudaGraph_t graph, const char* path, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaUserObjectCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectCreate(cyruntime.cudaUserObject_t* object_out, void* ptr, cyruntime.cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaUserObjectRetain' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectRetain(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaUserObjectRelease' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectRelease(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphRetainUserObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRetainUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphReleaseUserObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphReleaseUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphAddNode_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddNode_v2(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.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 {{endif}} {{if 'cudaGraphNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeSetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphExecNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecNodeSetParams(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGraphConditionalHandleCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphConditionalHandleCreate(cyruntime.cudaGraphConditionalHandle* pHandle_out, cyruntime.cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDriverEntryPoint' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetDriverEntryPointByVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryLoadData' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryLoadData(cyruntime.cudaLibrary_t* library, const void* code, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.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 {{endif}} {{if 'cudaLibraryLoadFromFile' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryLoadFromFile(cyruntime.cudaLibrary_t* library, const char* fileName, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.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 {{endif}} {{if 'cudaLibraryUnload' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryUnload(cyruntime.cudaLibrary_t library) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetKernel' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetKernel(cyruntime.cudaKernel_t* pKernel, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetGlobal' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetManaged' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetUnifiedFunction' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cyruntime.cudaLibrary_t library, const char* symbol) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryGetKernelCount' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaLibraryEnumerateKernels' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryEnumerateKernels(cyruntime.cudaKernel_t* kernels, unsigned int numKernels, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaKernelSetAttributeForDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaKernelSetAttributeForDevice(cyruntime.cudaKernel_t kernel, cyruntime.cudaFuncAttribute attr, int value, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetExportTable' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetExportTable(const void** ppExportTable, const cyruntime.cudaUUID_t* pExportTableId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaGetKernel' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetKernel(cyruntime.cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'make_cudaPitchedPtr' in found_functions}} -cdef cyruntime.cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil +cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil {{endif}} {{if 'make_cudaPos' in found_functions}} -cdef cyruntime.cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil +cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil {{endif}} {{if 'make_cudaExtent' in found_functions}} -cdef cyruntime.cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil +cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil {{endif}} {{if 'cudaProfilerStart' in found_functions}} -cdef cyruntime.cudaError_t _cudaProfilerStart() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} {{if 'cudaProfilerStop' in found_functions}} -cdef cyruntime.cudaError_t _cudaProfilerStop() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil {{endif}} diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in index b5e4e5060..6bfefac5c 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime_ptds.pyx.in @@ -6,1762 +6,1764 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. cdef extern from "": """ #define CUDA_API_PER_THREAD_DEFAULT_STREAM """ -include "cyruntime.pxi" +include "../cyruntime_functions.pxi" + +cimport cython {{if 'cudaDeviceReset' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceReset() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceReset() {{endif}} {{if 'cudaDeviceSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSynchronize() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceSynchronize() {{endif}} {{if 'cudaDeviceSetLimit' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetLimit(cyruntime.cudaLimit limit, size_t value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceSetLimit(limit, value) {{endif}} {{if 'cudaDeviceGetLimit' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetLimit(size_t* pValue, cyruntime.cudaLimit limit) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetLimit(pValue, limit) {{endif}} {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cyruntime.cudaChannelFormatDesc* fmtDesc, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) {{endif}} {{if 'cudaDeviceGetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetCacheConfig(cyruntime.cudaFuncCache* pCacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetCacheConfig(pCacheConfig) {{endif}} {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) {{endif}} {{if 'cudaDeviceSetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetCacheConfig(cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceSetCacheConfig(cacheConfig) {{endif}} {{if 'cudaDeviceGetByPCIBusId' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetByPCIBusId(device, pciBusId) {{endif}} {{if 'cudaDeviceGetPCIBusId' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetPCIBusId(pciBusId, length, device) {{endif}} {{if 'cudaIpcGetEventHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcGetEventHandle(cyruntime.cudaIpcEventHandle_t* handle, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaIpcGetEventHandle(handle, event) {{endif}} {{if 'cudaIpcOpenEventHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcOpenEventHandle(cyruntime.cudaEvent_t* event, cyruntime.cudaIpcEventHandle_t handle) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaIpcOpenEventHandle(event, handle) {{endif}} {{if 'cudaIpcGetMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcGetMemHandle(cyruntime.cudaIpcMemHandle_t* handle, void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaIpcGetMemHandle(handle, devPtr) {{endif}} {{if 'cudaIpcOpenMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cyruntime.cudaIpcMemHandle_t handle, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaIpcOpenMemHandle(devPtr, handle, flags) {{endif}} {{if 'cudaIpcCloseMemHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaIpcCloseMemHandle(devPtr) {{endif}} {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cyruntime.cudaFlushGPUDirectRDMAWritesTarget target, cyruntime.cudaFlushGPUDirectRDMAWritesScope scope) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceFlushGPUDirectRDMAWrites(target, scope) {{endif}} {{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cyruntime.cudaAsyncCallback callbackFunc, void* userData, cyruntime.cudaAsyncCallbackHandle_t* callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) {{endif}} {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cyruntime.cudaAsyncCallbackHandle_t callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceUnregisterAsyncNotification(device, callback) {{endif}} {{if 'cudaDeviceGetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetSharedMemConfig(cyruntime.cudaSharedMemConfig* pConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetSharedMemConfig(pConfig) {{endif}} {{if 'cudaDeviceSetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetSharedMemConfig(cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceSetSharedMemConfig(config) {{endif}} {{if 'cudaGetLastError' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetLastError() {{endif}} {{if 'cudaPeekAtLastError' in found_functions}} -cdef cyruntime.cudaError_t _cudaPeekAtLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: return cudaPeekAtLastError() {{endif}} {{if 'cudaGetErrorName' in found_functions}} -cdef const char* _cudaGetErrorName(cyruntime.cudaError_t error) except ?NULL nogil: +cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil: return cudaGetErrorName(error) {{endif}} {{if 'cudaGetErrorString' in found_functions}} -cdef const char* _cudaGetErrorString(cyruntime.cudaError_t error) except ?NULL nogil: +cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil: return cudaGetErrorString(error) {{endif}} {{if 'cudaGetDeviceCount' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceCount(int* count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetDeviceCount(count) {{endif}} {{if 'cudaGetDeviceProperties_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceProperties_v2(cyruntime.cudaDeviceProp* prop, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDeviceProperties_v2(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetDeviceProperties_v2(prop, device) {{endif}} {{if 'cudaDeviceGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetAttribute(int* value, cyruntime.cudaDeviceAttr attr, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetAttribute(value, attr, device) {{endif}} {{if 'cudaDeviceGetDefaultMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetDefaultMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetDefaultMemPool(memPool, device) {{endif}} {{if 'cudaDeviceSetMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetMemPool(int device, cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceSetMemPool(device, memPool) {{endif}} {{if 'cudaDeviceGetMemPool' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetMemPool(memPool, device) {{endif}} {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) {{endif}} {{if 'cudaDeviceGetP2PAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetP2PAttribute(int* value, cyruntime.cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) {{endif}} {{if 'cudaChooseDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaChooseDevice(int* device, const cyruntime.cudaDeviceProp* prop) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaChooseDevice(device, prop) {{endif}} {{if 'cudaInitDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaInitDevice(device, deviceFlags, flags) {{endif}} {{if 'cudaSetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaSetDevice(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaSetDevice(device) {{endif}} {{if 'cudaGetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDevice(int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetDevice(device) {{endif}} {{if 'cudaSetDeviceFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaSetDeviceFlags(flags) {{endif}} {{if 'cudaGetDeviceFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetDeviceFlags(flags) {{endif}} {{if 'cudaStreamCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreate(cyruntime.cudaStream_t* pStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamCreate(pStream) {{endif}} {{if 'cudaStreamCreateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreateWithFlags(cyruntime.cudaStream_t* pStream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamCreateWithFlags(pStream, flags) {{endif}} {{if 'cudaStreamCreateWithPriority' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCreateWithPriority(cyruntime.cudaStream_t* pStream, unsigned int flags, int priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamCreateWithPriority(pStream, flags, priority) {{endif}} {{if 'cudaStreamGetPriority' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetPriority(cyruntime.cudaStream_t hStream, int* priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamGetPriority(hStream, priority) {{endif}} {{if 'cudaStreamGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetFlags(cyruntime.cudaStream_t hStream, unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamGetFlags(hStream, flags) {{endif}} {{if 'cudaStreamGetId' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetId(cyruntime.cudaStream_t hStream, unsigned long long* streamId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamGetId(hStream, streamId) {{endif}} {{if 'cudaStreamGetDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetDevice(cyruntime.cudaStream_t hStream, int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamGetDevice(hStream, device) {{endif}} {{if 'cudaCtxResetPersistingL2Cache' in found_functions}} -cdef cyruntime.cudaError_t _cudaCtxResetPersistingL2Cache() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: return cudaCtxResetPersistingL2Cache() {{endif}} {{if 'cudaStreamCopyAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamCopyAttributes(cyruntime.cudaStream_t dst, cyruntime.cudaStream_t src) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamCopyAttributes(dst, src) {{endif}} {{if 'cudaStreamGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, cyruntime.cudaStreamAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamGetAttribute(hStream, attr, value_out) {{endif}} {{if 'cudaStreamSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamSetAttribute(cyruntime.cudaStream_t hStream, cyruntime.cudaStreamAttrID attr, const cyruntime.cudaStreamAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamSetAttribute(hStream, attr, value) {{endif}} {{if 'cudaStreamDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamDestroy(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamDestroy(stream) {{endif}} {{if 'cudaStreamWaitEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamWaitEvent(cyruntime.cudaStream_t stream, cyruntime.cudaEvent_t event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamWaitEvent(stream, event, flags) {{endif}} {{if 'cudaStreamAddCallback' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamAddCallback(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamAddCallback(stream, callback, userData, flags) {{endif}} {{if 'cudaStreamSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamSynchronize(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamSynchronize(stream) {{endif}} {{if 'cudaStreamQuery' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamQuery(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamQuery(stream) {{endif}} {{if 'cudaStreamAttachMemAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamAttachMemAsync(cyruntime.cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamAttachMemAsync(stream, devPtr, length, flags) {{endif}} {{if 'cudaStreamBeginCapture' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamBeginCapture(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamBeginCapture(stream, mode) {{endif}} {{if 'cudaStreamBeginCaptureToGraph' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamBeginCaptureToGraph(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.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: return cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode) {{endif}} {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} -cdef cyruntime.cudaError_t _cudaThreadExchangeStreamCaptureMode(cyruntime.cudaStreamCaptureMode* mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaThreadExchangeStreamCaptureMode(mode) {{endif}} {{if 'cudaStreamEndCapture' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamEndCapture(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamEndCapture(stream, pGraph) {{endif}} {{if 'cudaStreamIsCapturing' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamIsCapturing(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* pCaptureStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamIsCapturing(stream, pCaptureStatus) {{endif}} {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v2(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef 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) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamGetCaptureInfo_v2_ptsz(stream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out) {{endif}} {{if 'cudaStreamGetCaptureInfo_v3' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamGetCaptureInfo_v3(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cyruntime.cudaGraph_t* graph_out, const cyruntime.cudaGraphNode_t** dependencies_out, const cyruntime.cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cyruntime.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: return cudaStreamGetCaptureInfo_v3(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out) {{endif}} {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaStreamUpdateCaptureDependencies(stream, dependencies, numDependencies, flags) {{endif}} {{if 'cudaStreamUpdateCaptureDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaStreamUpdateCaptureDependencies_v2(cyruntime.cudaStream_t stream, cyruntime.cudaGraphNode_t* dependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cyruntime.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: return cudaStreamUpdateCaptureDependencies_v2(stream, dependencies, dependencyData, numDependencies, flags) {{endif}} {{if 'cudaEventCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventCreate(cyruntime.cudaEvent_t* event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventCreate(event) {{endif}} {{if 'cudaEventCreateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventCreateWithFlags(cyruntime.cudaEvent_t* event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventCreateWithFlags(event, flags) {{endif}} {{if 'cudaEventRecord' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventRecord(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventRecord(event, stream) {{endif}} {{if 'cudaEventRecordWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventRecordWithFlags(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventRecordWithFlags(event, stream, flags) {{endif}} {{if 'cudaEventQuery' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventQuery(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventQuery(event) {{endif}} {{if 'cudaEventSynchronize' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventSynchronize(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventSynchronize(event) {{endif}} {{if 'cudaEventDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventDestroy(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventDestroy(event) {{endif}} {{if 'cudaEventElapsedTime' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventElapsedTime(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventElapsedTime(ms, start, end) {{endif}} {{if 'cudaEventElapsedTime_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaEventElapsedTime_v2(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaEventElapsedTime_v2(ms, start, end) {{endif}} {{if 'cudaImportExternalMemory' in found_functions}} -cdef cyruntime.cudaError_t _cudaImportExternalMemory(cyruntime.cudaExternalMemory_t* extMem_out, const cyruntime.cudaExternalMemoryHandleDesc* memHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaImportExternalMemory(extMem_out, memHandleDesc) {{endif}} {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} -cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryBufferDesc* bufferDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) {{endif}} {{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmap, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) {{endif}} {{if 'cudaDestroyExternalMemory' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyExternalMemory(cyruntime.cudaExternalMemory_t extMem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDestroyExternalMemory(extMem) {{endif}} {{if 'cudaImportExternalSemaphore' in found_functions}} -cdef cyruntime.cudaError_t _cudaImportExternalSemaphore(cyruntime.cudaExternalSemaphore_t* extSem_out, const cyruntime.cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaImportExternalSemaphore(extSem_out, semHandleDesc) {{endif}} {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaSignalExternalSemaphoresAsync_v2_ptsz(extSemArray, paramsArray, numExtSems, stream) {{endif}} {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cyruntime.cudaExternalSemaphore_t* extSemArray, const cyruntime.cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaWaitExternalSemaphoresAsync_v2_ptsz(extSemArray, paramsArray, numExtSems, stream) {{endif}} {{if 'cudaDestroyExternalSemaphore' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyExternalSemaphore(cyruntime.cudaExternalSemaphore_t extSem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDestroyExternalSemaphore(extSem) {{endif}} {{if 'cudaFuncSetCacheConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetCacheConfig(const void* func, cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFuncSetCacheConfig(func, cacheConfig) {{endif}} {{if 'cudaFuncGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncGetAttributes(cyruntime.cudaFuncAttributes* attr, const void* func) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFuncGetAttributes(attr, func) {{endif}} {{if 'cudaFuncSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetAttribute(const void* func, cyruntime.cudaFuncAttribute attr, int value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFuncSetAttribute(func, attr, value) {{endif}} {{if 'cudaLaunchHostFunc' in found_functions}} -cdef cyruntime.cudaError_t _cudaLaunchHostFunc(cyruntime.cudaStream_t stream, cyruntime.cudaHostFn_t fn, void* userData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaLaunchHostFunc(stream, fn, userData) {{endif}} {{if 'cudaFuncSetSharedMemConfig' in found_functions}} -cdef cyruntime.cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFuncSetSharedMemConfig(func, config) {{endif}} {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) {{endif}} {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) {{endif}} {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) {{endif}} {{if 'cudaMallocManaged' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMallocManaged(devPtr, size, flags) {{endif}} {{if 'cudaMalloc' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMalloc(devPtr, size) {{endif}} {{if 'cudaMallocHost' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMallocHost(ptr, size) {{endif}} {{if 'cudaMallocPitch' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMallocPitch(devPtr, pitch, width, height) {{endif}} {{if 'cudaMallocArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMallocArray(array, desc, width, height, flags) {{endif}} {{if 'cudaFree' in found_functions}} -cdef cyruntime.cudaError_t _cudaFree(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFree(devPtr) {{endif}} {{if 'cudaFreeHost' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeHost(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFreeHost(ptr) {{endif}} {{if 'cudaFreeArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeArray(cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFreeArray(array) {{endif}} {{if 'cudaFreeMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeMipmappedArray(cyruntime.cudaMipmappedArray_t mipmappedArray) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFreeMipmappedArray(mipmappedArray) {{endif}} {{if 'cudaHostAlloc' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaHostAlloc(pHost, size, flags) {{endif}} {{if 'cudaHostRegister' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaHostRegister(ptr, size, flags) {{endif}} {{if 'cudaHostUnregister' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostUnregister(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaHostUnregister(ptr) {{endif}} {{if 'cudaHostGetDevicePointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaHostGetDevicePointer(pDevice, pHost, flags) {{endif}} {{if 'cudaHostGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaHostGetFlags(pFlags, pHost) {{endif}} {{if 'cudaMalloc3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc3D(cyruntime.cudaPitchedPtr* pitchedDevPtr, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMalloc3D(pitchedDevPtr, extent) {{endif}} {{if 'cudaMalloc3DArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMalloc3DArray(cyruntime.cudaArray_t* array, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMalloc3DArray(array, desc, extent, flags) {{endif}} {{if 'cudaMallocMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, const cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) {{endif}} {{if 'cudaGetMipmappedArrayLevel' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetMipmappedArrayLevel(cyruntime.cudaArray_t* levelArray, cyruntime.cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) {{endif}} {{if 'cudaMemcpy3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3D(const cyruntime.cudaMemcpy3DParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpy3D(p) {{endif}} {{if 'cudaMemcpy3DPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DPeer(const cyruntime.cudaMemcpy3DPeerParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpy3DPeer(p) {{endif}} {{if 'cudaMemcpy3DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DAsync(const cyruntime.cudaMemcpy3DParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpy3DAsync(p, stream) {{endif}} {{if 'cudaMemcpy3DPeerAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DPeerAsync(const cyruntime.cudaMemcpy3DPeerParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpy3DPeerAsync(p, stream) {{endif}} {{if 'cudaMemGetInfo' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemGetInfo(free, total) {{endif}} {{if 'cudaArrayGetInfo' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetInfo(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaExtent* extent, unsigned int* flags, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaArrayGetInfo(desc, extent, flags, array) {{endif}} {{if 'cudaArrayGetPlane' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetPlane(cyruntime.cudaArray_t* pPlaneArray, cyruntime.cudaArray_t hArray, unsigned int planeIdx) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) {{endif}} {{if 'cudaArrayGetMemoryRequirements' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaArray_t array, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaArrayGetMemoryRequirements(memoryRequirements, array, device) {{endif}} {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} -cdef cyruntime.cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaMipmappedArray_t mipmap, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) {{endif}} {{if 'cudaArrayGetSparseProperties' in found_functions}} -cdef cyruntime.cudaError_t _cudaArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaArrayGetSparseProperties(sparseProperties, array) {{endif}} {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} -cdef cyruntime.cudaError_t _cudaMipmappedArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaMipmappedArray_t mipmap) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) {{endif}} {{if 'cudaMemcpy' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpy(dst, src, count, kind) {{endif}} {{if 'cudaMemcpyPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) {{endif}} {{if 'cudaMemcpy2D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) {{endif}} {{if 'cudaMemcpy2DToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) {{endif}} {{if 'cudaMemcpy2DFromArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) {{endif}} {{if 'cudaMemcpy2DArrayToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) {{endif}} {{if 'cudaMemcpyAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpyAsync(dst, src, count, kind, stream) {{endif}} {{if 'cudaMemcpyPeerAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) {{endif}} {{if 'cudaMemcpyBatchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, cyruntime.cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, cyruntime.cudaStream_t stream) except ?cyruntime.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: return cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, failIdx, stream) {{endif}} {{if 'cudaMemcpy3DBatchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cyruntime.cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemcpy3DBatchAsync(numOps, opList, failIdx, flags, stream) {{endif}} {{if 'cudaMemcpy2DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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: return cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) {{endif}} {{if 'cudaMemcpy2DToArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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: return cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) {{endif}} {{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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: return cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) {{endif}} {{if 'cudaMemset' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemset(devPtr, value, count) {{endif}} {{if 'cudaMemset2D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemset2D(devPtr, pitch, value, width, height) {{endif}} {{if 'cudaMemset3D' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset3D(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemset3D(pitchedDevPtr, value, extent) {{endif}} {{if 'cudaMemsetAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemsetAsync(devPtr, value, count, stream) {{endif}} {{if 'cudaMemset2DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cyruntime.cudaStream_t stream) except ?cyruntime.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: return cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) {{endif}} {{if 'cudaMemset3DAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemset3DAsync(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) {{endif}} {{if 'cudaMemPrefetchAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPrefetchAsync(devPtr, count, dstDevice, stream) {{endif}} {{if 'cudaMemPrefetchAsync_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cyruntime.cudaMemLocation location, unsigned int flags, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPrefetchAsync_v2(devPtr, count, location, flags, stream) {{endif}} {{if 'cudaMemAdvise' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemAdvise(devPtr, count, advice, device) {{endif}} {{if 'cudaMemAdvise_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, cyruntime.cudaMemoryAdvise advice, cyruntime.cudaMemLocation location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemAdvise_v2(devPtr, count, advice, location) {{endif}} {{if 'cudaMemRangeGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cyruntime.cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) {{endif}} {{if 'cudaMemRangeGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cyruntime.cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cyruntime.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: return cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) {{endif}} {{if 'cudaMemcpyToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyToArray(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) {{endif}} {{if 'cudaMemcpyFromArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyFromArray(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) {{endif}} {{if 'cudaMemcpyArrayToArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyArrayToArray(cyruntime.cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cyruntime.cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) {{endif}} {{if 'cudaMemcpyToArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyToArrayAsync(cyruntime.cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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: return cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) {{endif}} {{if 'cudaMemcpyFromArrayAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cyruntime.cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cyruntime.cudaMemcpyKind kind, cyruntime.cudaStream_t stream) except ?cyruntime.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: return cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) {{endif}} {{if 'cudaMallocAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMallocAsync(devPtr, size, hStream) {{endif}} {{if 'cudaFreeAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaFreeAsync(void* devPtr, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaFreeAsync(devPtr, hStream) {{endif}} {{if 'cudaMemPoolTrimTo' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolTrimTo(cyruntime.cudaMemPool_t memPool, size_t minBytesToKeep) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolTrimTo(memPool, minBytesToKeep) {{endif}} {{if 'cudaMemPoolSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolSetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolSetAttribute(memPool, attr, value) {{endif}} {{if 'cudaMemPoolGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolGetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolGetAttribute(memPool, attr, value) {{endif}} {{if 'cudaMemPoolSetAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolSetAccess(cyruntime.cudaMemPool_t memPool, const cyruntime.cudaMemAccessDesc* descList, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolSetAccess(memPool, descList, count) {{endif}} {{if 'cudaMemPoolGetAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolGetAccess(cyruntime.cudaMemAccessFlags* flags, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemLocation* location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolGetAccess(flags, memPool, location) {{endif}} {{if 'cudaMemPoolCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolCreate(cyruntime.cudaMemPool_t* memPool, const cyruntime.cudaMemPoolProps* poolProps) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolCreate(memPool, poolProps) {{endif}} {{if 'cudaMemPoolDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolDestroy(cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolDestroy(memPool) {{endif}} {{if 'cudaMallocFromPoolAsync' in found_functions}} -cdef cyruntime.cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cyruntime.cudaMemPool_t memPool, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMallocFromPoolAsync(ptr, size, memPool, stream) {{endif}} {{if 'cudaMemPoolExportToShareableHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) {{endif}} {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolImportFromShareableHandle(cyruntime.cudaMemPool_t* memPool, void* shareableHandle, cyruntime.cudaMemAllocationHandleType handleType, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) {{endif}} {{if 'cudaMemPoolExportPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolExportPointer(cyruntime.cudaMemPoolPtrExportData* exportData, void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolExportPointer(exportData, ptr) {{endif}} {{if 'cudaMemPoolImportPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaMemPoolImportPointer(void** ptr, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolPtrExportData* exportData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaMemPoolImportPointer(ptr, memPool, exportData) {{endif}} {{if 'cudaPointerGetAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaPointerGetAttributes(cyruntime.cudaPointerAttributes* attributes, const void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaPointerGetAttributes(attributes, ptr) {{endif}} {{if 'cudaDeviceCanAccessPeer' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) {{endif}} {{if 'cudaDeviceEnablePeerAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceEnablePeerAccess(peerDevice, flags) {{endif}} {{if 'cudaDeviceDisablePeerAccess' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceDisablePeerAccess(peerDevice) {{endif}} {{if 'cudaGraphicsUnregisterResource' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsUnregisterResource(cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphicsUnregisterResource(resource) {{endif}} {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceSetMapFlags(cyruntime.cudaGraphicsResource_t resource, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphicsResourceSetMapFlags(resource, flags) {{endif}} {{if 'cudaGraphicsMapResources' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsMapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphicsMapResources(count, resources, stream) {{endif}} {{if 'cudaGraphicsUnmapResources' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsUnmapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphicsUnmapResources(count, resources, stream) {{endif}} {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) {{endif}} {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsSubResourceGetMappedArray(cyruntime.cudaArray_t* array, cyruntime.cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) {{endif}} {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) {{endif}} {{if 'cudaGetChannelDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetChannelDesc(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaArray_const_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetChannelDesc(desc, array) {{endif}} {{if 'cudaCreateChannelDesc' in found_functions}} @cython.show_performance_hints(False) -cdef cyruntime.cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cyruntime.cudaChannelFormatKind f) except* nogil: +cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: return cudaCreateChannelDesc(x, y, z, w, f) {{endif}} {{if 'cudaCreateTextureObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaCreateTextureObject(cyruntime.cudaTextureObject_t* pTexObject, const cyruntime.cudaResourceDesc* pResDesc, const cyruntime.cudaTextureDesc* pTexDesc, const cyruntime.cudaResourceViewDesc* pResViewDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) {{endif}} {{if 'cudaDestroyTextureObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroyTextureObject(cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDestroyTextureObject(texObject) {{endif}} {{if 'cudaGetTextureObjectResourceDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetTextureObjectResourceDesc(pResDesc, texObject) {{endif}} {{if 'cudaGetTextureObjectTextureDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectTextureDesc(cyruntime.cudaTextureDesc* pTexDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetTextureObjectTextureDesc(pTexDesc, texObject) {{endif}} {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetTextureObjectResourceViewDesc(cyruntime.cudaResourceViewDesc* pResViewDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) {{endif}} {{if 'cudaCreateSurfaceObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaCreateSurfaceObject(cyruntime.cudaSurfaceObject_t* pSurfObject, const cyruntime.cudaResourceDesc* pResDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaCreateSurfaceObject(pSurfObject, pResDesc) {{endif}} {{if 'cudaDestroySurfaceObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaDestroySurfaceObject(cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDestroySurfaceObject(surfObject) {{endif}} {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetSurfaceObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) {{endif}} {{if 'cudaDriverGetVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDriverGetVersion(driverVersion) {{endif}} {{if 'cudaRuntimeGetVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaRuntimeGetVersion(runtimeVersion) {{endif}} {{if 'cudaGraphCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphCreate(cyruntime.cudaGraph_t* pGraph, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphCreate(pGraph, flags) {{endif}} {{if 'cudaGraphAddKernelNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddKernelNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.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: return cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) {{endif}} {{if 'cudaGraphKernelNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphKernelNodeGetParams(node, pNodeParams) {{endif}} {{if 'cudaGraphKernelNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphKernelNodeSetParams(node, pNodeParams) {{endif}} {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeCopyAttributes(cyruntime.cudaGraphNode_t hSrc, cyruntime.cudaGraphNode_t hDst) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphKernelNodeCopyAttributes(hSrc, hDst) {{endif}} {{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeGetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, cyruntime.cudaKernelNodeAttrValue* value_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphKernelNodeGetAttribute(hNode, attr, value_out) {{endif}} {{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphKernelNodeSetAttribute(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaKernelNodeAttrID attr, const cyruntime.cudaKernelNodeAttrValue* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphKernelNodeSetAttribute(hNode, attr, value) {{endif}} {{if 'cudaGraphAddMemcpyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemcpy3DParms* pCopyParams) except ?cyruntime.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: return cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams) {{endif}} {{if 'cudaGraphAddMemcpyNode1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemcpyNode1D(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind) {{endif}} {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphMemcpyNodeGetParams(node, pNodeParams) {{endif}} {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphMemcpyNodeSetParams(node, pNodeParams) {{endif}} {{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemcpyNodeSetParams1D(cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind) {{endif}} {{if 'cudaGraphAddMemsetNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemsetNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaMemsetParams* pMemsetParams) except ?cyruntime.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: return cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams) {{endif}} {{if 'cudaGraphMemsetNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemsetNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphMemsetNodeGetParams(node, pNodeParams) {{endif}} {{if 'cudaGraphMemsetNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemsetNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphMemsetNodeSetParams(node, pNodeParams) {{endif}} {{if 'cudaGraphAddHostNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddHostNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.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: return cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams) {{endif}} {{if 'cudaGraphHostNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphHostNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphHostNodeGetParams(node, pNodeParams) {{endif}} {{if 'cudaGraphHostNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphHostNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphHostNodeSetParams(node, pNodeParams) {{endif}} {{if 'cudaGraphAddChildGraphNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddChildGraphNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraph_t childGraph) except ?cyruntime.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: return cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph) {{endif}} {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphChildGraphNodeGetGraph(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphChildGraphNodeGetGraph(node, pGraph) {{endif}} {{if 'cudaGraphAddEmptyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEmptyNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies) {{endif}} {{if 'cudaGraphAddEventRecordNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEventRecordNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.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: return cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event) {{endif}} {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphEventRecordNodeGetEvent(node, event_out) {{endif}} {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventRecordNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphEventRecordNodeSetEvent(node, event) {{endif}} {{if 'cudaGraphAddEventWaitNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddEventWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaEvent_t event) except ?cyruntime.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: return cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event) {{endif}} {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphEventWaitNodeGetEvent(node, event_out) {{endif}} {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphEventWaitNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphEventWaitNodeSetEvent(node, event) {{endif}} {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.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: return cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) {{endif}} {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreSignalNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out) {{endif}} {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams) {{endif}} {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.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: return cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) {{endif}} {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreWaitNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out) {{endif}} {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams) {{endif}} {{if 'cudaGraphAddMemAllocNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemAllocNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaMemAllocNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) {{endif}} {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemAllocNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemAllocNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphMemAllocNodeGetParams(node, params_out) {{endif}} {{if 'cudaGraphAddMemFreeNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddMemFreeNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr) {{endif}} {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphMemFreeNodeGetParams(cyruntime.cudaGraphNode_t node, void* dptr_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphMemFreeNodeGetParams(node, dptr_out) {{endif}} {{if 'cudaDeviceGraphMemTrim' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGraphMemTrim(device) {{endif}} {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceGetGraphMemAttribute(device, attr, value) {{endif}} {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} -cdef cyruntime.cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaDeviceSetGraphMemAttribute(device, attr, value) {{endif}} {{if 'cudaGraphClone' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphClone(cyruntime.cudaGraph_t* pGraphClone, cyruntime.cudaGraph_t originalGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphClone(pGraphClone, originalGraph) {{endif}} {{if 'cudaGraphNodeFindInClone' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeFindInClone(cyruntime.cudaGraphNode_t* pNode, cyruntime.cudaGraphNode_t originalNode, cyruntime.cudaGraph_t clonedGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph) {{endif}} {{if 'cudaGraphNodeGetType' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetType(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeType* pType) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeGetType(node, pType) {{endif}} {{if 'cudaGraphGetNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* nodes, size_t* numNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphGetNodes(graph, nodes, numNodes) {{endif}} {{if 'cudaGraphGetRootNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetRootNodes(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes) {{endif}} {{if 'cudaGraphGetEdges' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetEdges(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphGetEdges(graph, from_, to, numEdges) {{endif}} {{if 'cudaGraphGetEdges_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphGetEdges_v2(cyruntime.cudaGraph_t graph, cyruntime.cudaGraphNode_t* from_, cyruntime.cudaGraphNode_t* to, cyruntime.cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphGetEdges_v2(graph, from_, to, edgeData, numEdges) {{endif}} {{if 'cudaGraphNodeGetDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeGetDependencies(node, pDependencies, pNumDependencies) {{endif}} {{if 'cudaGraphNodeGetDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependencies_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependencies, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeGetDependencies_v2(node, pDependencies, edgeData, pNumDependencies) {{endif}} {{if 'cudaGraphNodeGetDependentNodes' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeGetDependentNodes(node, pDependentNodes, pNumDependentNodes) {{endif}} {{if 'cudaGraphNodeGetDependentNodes_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetDependentNodes_v2(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNode_t* pDependentNodes, cyruntime.cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeGetDependentNodes_v2(node, pDependentNodes, edgeData, pNumDependentNodes) {{endif}} {{if 'cudaGraphAddDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphAddDependencies(graph, from_, to, numDependencies) {{endif}} {{if 'cudaGraphAddDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.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: return cudaGraphAddDependencies_v2(graph, from_, to, edgeData, numDependencies) {{endif}} {{if 'cudaGraphRemoveDependencies' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, size_t numDependencies) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphRemoveDependencies(graph, from_, to, numDependencies) {{endif}} {{if 'cudaGraphRemoveDependencies_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRemoveDependencies_v2(cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* from_, const cyruntime.cudaGraphNode_t* to, const cyruntime.cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cyruntime.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: return cudaGraphRemoveDependencies_v2(graph, from_, to, edgeData, numDependencies) {{endif}} {{if 'cudaGraphDestroyNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDestroyNode(cyruntime.cudaGraphNode_t node) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphDestroyNode(node) {{endif}} {{if 'cudaGraphInstantiate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiate(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphInstantiate(pGraphExec, graph, flags) {{endif}} {{if 'cudaGraphInstantiateWithFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiateWithFlags(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, unsigned long long flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphInstantiateWithFlags(pGraphExec, graph, flags) {{endif}} {{if 'cudaGraphInstantiateWithParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphInstantiateWithParams(cyruntime.cudaGraphExec_t* pGraphExec, cyruntime.cudaGraph_t graph, cyruntime.cudaGraphInstantiateParams* instantiateParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams) {{endif}} {{if 'cudaGraphExecGetFlags' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecGetFlags(cyruntime.cudaGraphExec_t graphExec, unsigned long long* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecGetFlags(graphExec, flags) {{endif}} {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecKernelNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams) {{endif}} {{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams) {{endif}} {{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, void* dst, const void* src, size_t count, cyruntime.cudaMemcpyKind kind) except ?cyruntime.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: return cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind) {{endif}} {{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecMemsetNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams) {{endif}} {{if 'cudaGraphExecHostNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecHostNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams) {{endif}} {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecChildGraphNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t childGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph) {{endif}} {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event) {{endif}} {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event) {{endif}} {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams) {{endif}} {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams) {{endif}} {{if 'cudaGraphNodeSetEnabled' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeSetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled) {{endif}} {{if 'cudaGraphNodeGetEnabled' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeGetEnabled(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled) {{endif}} {{if 'cudaGraphExecUpdate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecUpdate(cyruntime.cudaGraphExec_t hGraphExec, cyruntime.cudaGraph_t hGraph, cyruntime.cudaGraphExecUpdateResultInfo* resultInfo) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo) {{endif}} {{if 'cudaGraphUpload' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphUpload(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphUpload(graphExec, stream) {{endif}} {{if 'cudaGraphLaunch' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphLaunch(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphLaunch(graphExec, stream) {{endif}} {{if 'cudaGraphExecDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecDestroy(cyruntime.cudaGraphExec_t graphExec) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecDestroy(graphExec) {{endif}} {{if 'cudaGraphDestroy' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDestroy(cyruntime.cudaGraph_t graph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphDestroy(graph) {{endif}} {{if 'cudaGraphDebugDotPrint' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphDebugDotPrint(cyruntime.cudaGraph_t graph, const char* path, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphDebugDotPrint(graph, path, flags) {{endif}} {{if 'cudaUserObjectCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectCreate(cyruntime.cudaUserObject_t* object_out, void* ptr, cyruntime.cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags) {{endif}} {{if 'cudaUserObjectRetain' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectRetain(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaUserObjectRetain(object, count) {{endif}} {{if 'cudaUserObjectRelease' in found_functions}} -cdef cyruntime.cudaError_t _cudaUserObjectRelease(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaUserObjectRelease(object, count) {{endif}} {{if 'cudaGraphRetainUserObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphRetainUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphRetainUserObject(graph, object, count, flags) {{endif}} {{if 'cudaGraphReleaseUserObject' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphReleaseUserObject(cyruntime.cudaGraph_t graph, cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphReleaseUserObject(graph, object, count) {{endif}} {{if 'cudaGraphAddNode' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddNode(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphAddNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams) {{endif}} {{if 'cudaGraphAddNode_v2' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphAddNode_v2(cyruntime.cudaGraphNode_t* pGraphNode, cyruntime.cudaGraph_t graph, const cyruntime.cudaGraphNode_t* pDependencies, const cyruntime.cudaGraphEdgeData* dependencyData, size_t numDependencies, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.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: return cudaGraphAddNode_v2(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams) {{endif}} {{if 'cudaGraphNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphNodeSetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphNodeSetParams(node, nodeParams) {{endif}} {{if 'cudaGraphExecNodeSetParams' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphExecNodeSetParams(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphExecNodeSetParams(graphExec, node, nodeParams) {{endif}} {{if 'cudaGraphConditionalHandleCreate' in found_functions}} -cdef cyruntime.cudaError_t _cudaGraphConditionalHandleCreate(cyruntime.cudaGraphConditionalHandle* pHandle_out, cyruntime.cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags) {{endif}} {{if 'cudaGetDriverEntryPoint' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus) {{endif}} {{if 'cudaGetDriverEntryPointByVersion' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cyruntime.cudaDriverEntryPointQueryResult* driverStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus) {{endif}} {{if 'cudaLibraryLoadData' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryLoadData(cyruntime.cudaLibrary_t* library, const void* code, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.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: return cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) {{endif}} {{if 'cudaLibraryLoadFromFile' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryLoadFromFile(cyruntime.cudaLibrary_t* library, const char* fileName, cyruntime.cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cyruntime.cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cyruntime.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: return cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions) {{endif}} {{if 'cudaLibraryUnload' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryUnload(cyruntime.cudaLibrary_t library) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaLibraryUnload(library) {{endif}} {{if 'cudaLibraryGetKernel' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetKernel(cyruntime.cudaKernel_t* pKernel, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaLibraryGetKernel(pKernel, library, name) {{endif}} {{if 'cudaLibraryGetGlobal' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaLibraryGetGlobal(dptr, numbytes, library, name) {{endif}} {{if 'cudaLibraryGetManaged' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cyruntime.cudaLibrary_t library, const char* name) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaLibraryGetManaged(dptr, numbytes, library, name) {{endif}} {{if 'cudaLibraryGetUnifiedFunction' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cyruntime.cudaLibrary_t library, const char* symbol) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaLibraryGetUnifiedFunction(fptr, library, symbol) {{endif}} {{if 'cudaLibraryGetKernelCount' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaLibraryGetKernelCount(count, lib) {{endif}} {{if 'cudaLibraryEnumerateKernels' in found_functions}} -cdef cyruntime.cudaError_t _cudaLibraryEnumerateKernels(cyruntime.cudaKernel_t* kernels, unsigned int numKernels, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaLibraryEnumerateKernels(kernels, numKernels, lib) {{endif}} {{if 'cudaKernelSetAttributeForDevice' in found_functions}} -cdef cyruntime.cudaError_t _cudaKernelSetAttributeForDevice(cyruntime.cudaKernel_t kernel, cyruntime.cudaFuncAttribute attr, int value, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaKernelSetAttributeForDevice(kernel, attr, value, device) {{endif}} {{if 'cudaGetExportTable' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetExportTable(const void** ppExportTable, const cyruntime.cudaUUID_t* pExportTableId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetExportTable(ppExportTable, pExportTableId) {{endif}} {{if 'cudaGetKernel' in found_functions}} -cdef cyruntime.cudaError_t _cudaGetKernel(cyruntime.cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil: return cudaGetKernel(kernelPtr, entryFuncAddr) {{endif}} {{if 'make_cudaPitchedPtr' in found_functions}} @cython.show_performance_hints(False) -cdef cyruntime.cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil: +cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil: return make_cudaPitchedPtr(d, p, xsz, ysz) {{endif}} {{if 'make_cudaPos' in found_functions}} @cython.show_performance_hints(False) -cdef cyruntime.cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil: +cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil: return make_cudaPos(x, y, z) {{endif}} {{if 'make_cudaExtent' in found_functions}} @cython.show_performance_hints(False) -cdef cyruntime.cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil: +cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil: return make_cudaExtent(w, h, d) {{endif}} {{if 'cudaProfilerStart' in found_functions}} -cdef cyruntime.cudaError_t _cudaProfilerStart() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil: return cudaProfilerStart() {{endif}} {{if 'cudaProfilerStop' in found_functions}} -cdef cyruntime.cudaError_t _cudaProfilerStop() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil: +cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil: return cudaProfilerStop() {{endif}} diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd b/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd index 847debf83..c3e5ce607 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink.pxd @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 12.0.1 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 12.0.1 to 12.9.0. Do not modify it directly. from ..cynvjitlink cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx index 9961a2105..bb61a3e22 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 12.0.1 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 12.0.1 to 12.9.0. Do not modify it directly. from libc.stdint cimport intptr_t diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx index 979820442..a2f77ca2e 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 12.0.1 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 12.0.1 to 12.9.0. Do not modify it directly. from libc.stdint cimport intptr_t diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm.pxd b/cuda_bindings/cuda/bindings/_internal/nvvm.pxd index ad5f616c2..1a8569488 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm.pxd +++ b/cuda_bindings/cuda/bindings/_internal/nvvm.pxd @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 11.0.3 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 11.0.3 to 12.9.0. Do not modify it directly. from ..cynvvm cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx index 64e78e75a..53675b094 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 11.0.3 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 11.0.3 to 12.9.0. Do not modify it directly. from libc.stdint cimport intptr_t diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx index 9f507e8e1..3f9f54a4d 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 11.0.3 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 11.0.3 to 12.9.0. Do not modify it directly. from libc.stdint cimport intptr_t diff --git a/cuda_bindings/cuda/bindings/_lib/cyruntime/utils.pyx.in b/cuda_bindings/cuda/bindings/_lib/cyruntime/utils.pyx.in index 990cbe25b..abe1d9940 100644 --- a/cuda_bindings/cuda/bindings/_lib/cyruntime/utils.pyx.in +++ b/cuda_bindings/cuda/bindings/_lib/cyruntime/utils.pyx.in @@ -991,4 +991,3 @@ cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, cydriver.CUeglFrame eglFrame[0].frameType = cudaEglFrameTypePitch else: return cudaErrorInvalidValue - diff --git a/cuda_bindings/cuda/bindings/_version.py b/cuda_bindings/cuda/bindings/_version.py index 184a71671..293274d14 100644 --- a/cuda_bindings/cuda/bindings/_version.py +++ b/cuda_bindings/cuda/bindings/_version.py @@ -1,4 +1,4 @@ -# Copyright 2024 NVIDIA Corporation. All rights reserved. +# Copyright 2024-2025 NVIDIA Corporation. All rights reserved. # # Please refer to the NVIDIA end user license agreement (EULA) associated # with this source code for terms and conditions that govern your use of @@ -6,4 +6,4 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. -__version__ = "12.8.0" +__version__ = "12.9.0" diff --git a/cuda_bindings/cuda/bindings/cydriver.pxd.in b/cuda_bindings/cuda/bindings/cydriver.pxd.in index c674c7703..68db6b032 100644 --- a/cuda_bindings/cuda/bindings/cydriver.pxd.in +++ b/cuda_bindings/cuda/bindings/cydriver.pxd.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. from libc.stdint cimport uint32_t, uint64_t @@ -556,8 +556,11 @@ cdef extern from "cuda.h": CU_DEVICE_ATTRIBUTE_D3D12_CIG_SUPPORTED = 135 CU_DEVICE_ATTRIBUTE_MEM_DECOMPRESS_ALGORITHM_MASK = 136 CU_DEVICE_ATTRIBUTE_MEM_DECOMPRESS_MAXIMUM_LENGTH = 137 + CU_DEVICE_ATTRIBUTE_VULKAN_CIG_SUPPORTED = 138 CU_DEVICE_ATTRIBUTE_GPU_PCI_DEVICE_ID = 139 CU_DEVICE_ATTRIBUTE_GPU_PCI_SUBSYSTEM_ID = 140 + CU_DEVICE_ATTRIBUTE_HOST_NUMA_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED = 141 + CU_DEVICE_ATTRIBUTE_HOST_NUMA_MEMORY_POOLS_SUPPORTED = 142 CU_DEVICE_ATTRIBUTE_HOST_NUMA_MULTINODE_IPC_SUPPORTED = 143 CU_DEVICE_ATTRIBUTE_MAX = 144 @@ -744,11 +747,20 @@ cdef extern from "cuda.h": CU_TARGET_COMPUTE_90 = 90 CU_TARGET_COMPUTE_100 = 100 CU_TARGET_COMPUTE_101 = 101 + CU_TARGET_COMPUTE_103 = 103 CU_TARGET_COMPUTE_120 = 120 + CU_TARGET_COMPUTE_121 = 121 CU_TARGET_COMPUTE_90A = 65626 CU_TARGET_COMPUTE_100A = 65636 CU_TARGET_COMPUTE_101A = 65637 + CU_TARGET_COMPUTE_103A = 65639 CU_TARGET_COMPUTE_120A = 65656 + CU_TARGET_COMPUTE_121A = 65657 + CU_TARGET_COMPUTE_100F = 131172 + CU_TARGET_COMPUTE_101F = 131173 + CU_TARGET_COMPUTE_103F = 131175 + CU_TARGET_COMPUTE_120F = 131192 + CU_TARGET_COMPUTE_121F = 131193 ctypedef CUjit_target_enum CUjit_target @@ -1172,6 +1184,7 @@ cdef extern from "cuda.h": cdef enum CUcigDataType_enum: CIG_DATA_TYPE_D3D12_COMMAND_QUEUE = 1 + CIG_DATA_TYPE_NV_BLOB = 2 ctypedef CUcigDataType_enum CUcigDataType @@ -2055,6 +2068,89 @@ cdef extern from "cuda.h": ctypedef CUmemPoolPtrExportData_v1 CUmemPoolPtrExportData + cdef enum CUmemcpyFlags_enum: + CU_MEMCPY_FLAG_DEFAULT = 0 + CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE = 1 + + ctypedef CUmemcpyFlags_enum CUmemcpyFlags + + cdef enum CUmemcpySrcAccessOrder_enum: + CU_MEMCPY_SRC_ACCESS_ORDER_INVALID = 0 + CU_MEMCPY_SRC_ACCESS_ORDER_STREAM = 1 + CU_MEMCPY_SRC_ACCESS_ORDER_DURING_API_CALL = 2 + CU_MEMCPY_SRC_ACCESS_ORDER_ANY = 3 + CU_MEMCPY_SRC_ACCESS_ORDER_MAX = 2147483647 + + ctypedef CUmemcpySrcAccessOrder_enum CUmemcpySrcAccessOrder + + cdef struct CUmemcpyAttributes_st: + CUmemcpySrcAccessOrder srcAccessOrder + CUmemLocation srcLocHint + CUmemLocation dstLocHint + unsigned int flags + + ctypedef CUmemcpyAttributes_st CUmemcpyAttributes_v1 + + ctypedef CUmemcpyAttributes_v1 CUmemcpyAttributes + + cdef enum CUmemcpy3DOperandType_enum: + CU_MEMCPY_OPERAND_TYPE_POINTER = 1 + CU_MEMCPY_OPERAND_TYPE_ARRAY = 2 + CU_MEMCPY_OPERAND_TYPE_MAX = 2147483647 + + ctypedef CUmemcpy3DOperandType_enum CUmemcpy3DOperandType + + cdef struct CUoffset3D_st: + size_t x + size_t y + size_t z + + ctypedef CUoffset3D_st CUoffset3D_v1 + + ctypedef CUoffset3D_v1 CUoffset3D + + cdef struct CUextent3D_st: + size_t width + size_t height + size_t depth + + ctypedef CUextent3D_st CUextent3D_v1 + + ctypedef CUextent3D_v1 CUextent3D + + cdef struct anon_struct23: + CUdeviceptr ptr + size_t rowLength + size_t layerHeight + CUmemLocation locHint + + cdef struct anon_struct24: + CUarray array + CUoffset3D offset + + cdef union anon_union12: + anon_struct23 ptr + anon_struct24 array + + cdef struct CUmemcpy3DOperand_st: + CUmemcpy3DOperandType type + anon_union12 op + + ctypedef CUmemcpy3DOperand_st CUmemcpy3DOperand_v1 + + ctypedef CUmemcpy3DOperand_v1 CUmemcpy3DOperand + + cdef struct CUDA_MEMCPY3D_BATCH_OP_st: + CUmemcpy3DOperand src + CUmemcpy3DOperand dst + CUextent3D extent + CUmemcpySrcAccessOrder srcAccessOrder + unsigned int flags + + ctypedef CUDA_MEMCPY3D_BATCH_OP_st CUDA_MEMCPY3D_BATCH_OP_v1 + + ctypedef CUDA_MEMCPY3D_BATCH_OP_v1 CUDA_MEMCPY3D_BATCH_OP + cdef struct CUDA_MEM_ALLOC_NODE_PARAMS_v1_st: CUmemPoolProps poolProps const CUmemAccessDesc* accessDescs @@ -2088,8 +2184,15 @@ cdef extern from "cuda.h": ctypedef CUgraphMem_attribute_enum CUgraphMem_attribute + cdef enum CUgraphChildGraphNodeOwnership_enum: + CU_GRAPH_CHILD_GRAPH_OWNERSHIP_CLONE = 0 + CU_GRAPH_CHILD_GRAPH_OWNERSHIP_MOVE = 1 + + ctypedef CUgraphChildGraphNodeOwnership_enum CUgraphChildGraphNodeOwnership + cdef struct CUDA_CHILD_GRAPH_NODE_PARAMS_st: CUgraph graph + CUgraphChildGraphNodeOwnership ownership ctypedef CUDA_CHILD_GRAPH_NODE_PARAMS_st CUDA_CHILD_GRAPH_NODE_PARAMS @@ -2222,89 +2325,6 @@ cdef extern from "cuda.h": ctypedef CUcheckpointUnlockArgs_st CUcheckpointUnlockArgs - cdef enum CUmemcpyFlags_enum: - CU_MEMCPY_FLAG_DEFAULT = 0 - CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE = 1 - - ctypedef CUmemcpyFlags_enum CUmemcpyFlags - - cdef enum CUmemcpySrcAccessOrder_enum: - CU_MEMCPY_SRC_ACCESS_ORDER_INVALID = 0 - CU_MEMCPY_SRC_ACCESS_ORDER_STREAM = 1 - CU_MEMCPY_SRC_ACCESS_ORDER_DURING_API_CALL = 2 - CU_MEMCPY_SRC_ACCESS_ORDER_ANY = 3 - CU_MEMCPY_SRC_ACCESS_ORDER_MAX = 2147483647 - - ctypedef CUmemcpySrcAccessOrder_enum CUmemcpySrcAccessOrder - - cdef struct CUmemcpyAttributes_st: - CUmemcpySrcAccessOrder srcAccessOrder - CUmemLocation srcLocHint - CUmemLocation dstLocHint - unsigned int flags - - ctypedef CUmemcpyAttributes_st CUmemcpyAttributes_v1 - - ctypedef CUmemcpyAttributes_v1 CUmemcpyAttributes - - cdef enum CUmemcpy3DOperandType_enum: - CU_MEMCPY_OPERAND_TYPE_POINTER = 1 - CU_MEMCPY_OPERAND_TYPE_ARRAY = 2 - CU_MEMCPY_OPERAND_TYPE_MAX = 2147483647 - - ctypedef CUmemcpy3DOperandType_enum CUmemcpy3DOperandType - - cdef struct CUoffset3D_st: - size_t x - size_t y - size_t z - - ctypedef CUoffset3D_st CUoffset3D_v1 - - ctypedef CUoffset3D_v1 CUoffset3D - - cdef struct CUextent3D_st: - size_t width - size_t height - size_t depth - - ctypedef CUextent3D_st CUextent3D_v1 - - ctypedef CUextent3D_v1 CUextent3D - - cdef struct anon_struct23: - CUdeviceptr ptr - size_t rowLength - size_t layerHeight - CUmemLocation locHint - - cdef struct anon_struct24: - CUarray array - CUoffset3D offset - - cdef union anon_union13: - anon_struct23 ptr - anon_struct24 array - - cdef struct CUmemcpy3DOperand_st: - CUmemcpy3DOperandType type - anon_union13 op - - ctypedef CUmemcpy3DOperand_st CUmemcpy3DOperand_v1 - - ctypedef CUmemcpy3DOperand_v1 CUmemcpy3DOperand - - cdef struct CUDA_MEMCPY3D_BATCH_OP_st: - CUmemcpy3DOperand src - CUmemcpy3DOperand dst - CUextent3D extent - CUmemcpySrcAccessOrder srcAccessOrder - unsigned int flags - - ctypedef CUDA_MEMCPY3D_BATCH_OP_st CUDA_MEMCPY3D_BATCH_OP_v1 - - ctypedef CUDA_MEMCPY3D_BATCH_OP_v1 CUDA_MEMCPY3D_BATCH_OP - cdef enum CUmoduleLoadingMode_enum: CU_MODULE_EAGER_LOADING = 1 CU_MODULE_LAZY_LOADING = 2 @@ -2315,6 +2335,7 @@ cdef extern from "cuda.h": CU_MEM_DECOMPRESS_UNSUPPORTED = 0 CU_MEM_DECOMPRESS_ALGORITHM_DEFLATE = 1 CU_MEM_DECOMPRESS_ALGORITHM_SNAPPY = 2 + CU_MEM_DECOMPRESS_ALGORITHM_LZ4 = 4 ctypedef CUmemDecompressAlgorithm_enum CUmemDecompressAlgorithm @@ -2388,6 +2409,20 @@ cdef extern from "cuda.h": ctypedef CUdevResource_v1 CUdevResource + cdef enum CUlogLevel_enum: + CU_LOG_LEVEL_ERROR = 0 + CU_LOG_LEVEL_WARNING = 1 + + ctypedef CUlogLevel_enum CUlogLevel + + cdef struct CUlogsCallbackEntry_st: + pass + ctypedef CUlogsCallbackEntry_st* CUlogsCallbackHandle + + ctypedef void (*CUlogsCallback)(void* data, CUlogLevel logLevel, char* message, size_t length) + + ctypedef unsigned int CUlogIterator + cdef extern from "cudaProfiler.h": cdef enum CUoutput_mode_enum: @@ -4803,6 +4838,31 @@ cdef CUresult cuStreamGetGreenCtx(CUstream hStream, CUgreenCtx* phCtx) except ?C cdef CUresult cuGreenCtxStreamCreate(CUstream* phStream, CUgreenCtx greenCtx, unsigned int flags, int priority) except ?CUDA_ERROR_NOT_FOUND nogil {{endif}} +{{if 'cuLogsRegisterCallback' in found_functions}} + +cdef CUresult cuLogsRegisterCallback(CUlogsCallback callbackFunc, void* userData, CUlogsCallbackHandle* callback_out) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + +{{if 'cuLogsUnregisterCallback' in found_functions}} + +cdef CUresult cuLogsUnregisterCallback(CUlogsCallbackHandle callback) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + +{{if 'cuLogsCurrent' in found_functions}} + +cdef CUresult cuLogsCurrent(CUlogIterator* iterator_out, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + +{{if 'cuLogsDumpToFile' in found_functions}} + +cdef CUresult cuLogsDumpToFile(CUlogIterator* iterator, const char* pathToFile, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + +{{if 'cuLogsDumpToMemory' in found_functions}} + +cdef CUresult cuLogsDumpToMemory(CUlogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil +{{endif}} + {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} cdef CUresult cuCheckpointProcessGetRestoreThreadId(int pid, int* tid) except ?CUDA_ERROR_NOT_FOUND nogil @@ -4938,7 +4998,7 @@ cdef CUresult cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResou cdef CUresult cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil {{endif}} -cdef enum: CUDA_VERSION = 12080 +cdef enum: CUDA_VERSION = 12090 cdef enum: CU_IPC_HANDLE_SIZE = 64 @@ -4948,6 +5008,8 @@ cdef enum: CU_STREAM_PER_THREAD = 2 cdef enum: CU_COMPUTE_ACCELERATED_TARGET_BASE = 65536 +cdef enum: CU_COMPUTE_FAMILY_TARGET_BASE = 131072 + cdef enum: CU_GRAPH_COND_ASSIGN_DEFAULT = 1 cdef enum: CU_GRAPH_KERNEL_NODE_PORT_DEFAULT = 0 @@ -5056,6 +5118,8 @@ cdef enum: CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION = 32 cdef enum: CU_TRSF_SEAMLESS_CUBEMAP = 64 +cdef enum: CU_LAUNCH_KERNEL_REQUIRED_BLOCK_DIM = 1 + cdef enum: CU_LAUNCH_PARAM_END_AS_INT = 0 cdef enum: CU_LAUNCH_PARAM_END = 0 diff --git a/cuda_bindings/cuda/bindings/cydriver.pyx.in b/cuda_bindings/cuda/bindings/cydriver.pyx.in index d85a5cfab..7697f0dec 100644 --- a/cuda_bindings/cuda/bindings/cydriver.pyx.in +++ b/cuda_bindings/cuda/bindings/cydriver.pyx.in @@ -6,8 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. -cimport cython +# This code was automatically generated with version 12.9.0. Do not modify it directly. cimport cuda.bindings._bindings.cydriver as cydriver {{if 'cuGetErrorString' in found_functions}} @@ -2656,6 +2655,36 @@ cdef CUresult cuGreenCtxStreamCreate(CUstream* phStream, CUgreenCtx greenCtx, un return cydriver._cuGreenCtxStreamCreate(phStream, greenCtx, flags, priority) {{endif}} +{{if 'cuLogsRegisterCallback' in found_functions}} + +cdef CUresult cuLogsRegisterCallback(CUlogsCallback callbackFunc, void* userData, CUlogsCallbackHandle* callback_out) except ?CUDA_ERROR_NOT_FOUND nogil: + return cydriver._cuLogsRegisterCallback(callbackFunc, userData, callback_out) +{{endif}} + +{{if 'cuLogsUnregisterCallback' in found_functions}} + +cdef CUresult cuLogsUnregisterCallback(CUlogsCallbackHandle callback) except ?CUDA_ERROR_NOT_FOUND nogil: + return cydriver._cuLogsUnregisterCallback(callback) +{{endif}} + +{{if 'cuLogsCurrent' in found_functions}} + +cdef CUresult cuLogsCurrent(CUlogIterator* iterator_out, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: + return cydriver._cuLogsCurrent(iterator_out, flags) +{{endif}} + +{{if 'cuLogsDumpToFile' in found_functions}} + +cdef CUresult cuLogsDumpToFile(CUlogIterator* iterator, const char* pathToFile, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: + return cydriver._cuLogsDumpToFile(iterator, pathToFile, flags) +{{endif}} + +{{if 'cuLogsDumpToMemory' in found_functions}} + +cdef CUresult cuLogsDumpToMemory(CUlogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil: + return cydriver._cuLogsDumpToMemory(iterator, buffer, size, flags) +{{endif}} + {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} cdef CUresult cuCheckpointProcessGetRestoreThreadId(int pid, int* tid) except ?CUDA_ERROR_NOT_FOUND nogil: diff --git a/cuda_bindings/cuda/bindings/cynvjitlink.pxd b/cuda_bindings/cuda/bindings/cynvjitlink.pxd index 2db1d0090..b9a16eb9b 100644 --- a/cuda_bindings/cuda/bindings/cynvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/cynvjitlink.pxd @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 12.0.1 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 12.0.1 to 12.9.0. Do not modify it directly. from libc.stdint cimport intptr_t, uint32_t diff --git a/cuda_bindings/cuda/bindings/cynvjitlink.pyx b/cuda_bindings/cuda/bindings/cynvjitlink.pyx index bca508d1f..4706eb13d 100644 --- a/cuda_bindings/cuda/bindings/cynvjitlink.pyx +++ b/cuda_bindings/cuda/bindings/cynvjitlink.pyx @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 12.0.1 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 12.0.1 to 12.9.0. Do not modify it directly. from ._internal cimport nvjitlink as _nvjitlink diff --git a/cuda_bindings/cuda/bindings/cynvrtc.pxd.in b/cuda_bindings/cuda/bindings/cynvrtc.pxd.in index 1fc318b38..7500078fb 100644 --- a/cuda_bindings/cuda/bindings/cynvrtc.pxd.in +++ b/cuda_bindings/cuda/bindings/cynvrtc.pxd.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. from libc.stdint cimport uint32_t, uint64_t diff --git a/cuda_bindings/cuda/bindings/cynvrtc.pyx.in b/cuda_bindings/cuda/bindings/cynvrtc.pyx.in index 71e091a00..1d5cbae01 100644 --- a/cuda_bindings/cuda/bindings/cynvrtc.pyx.in +++ b/cuda_bindings/cuda/bindings/cynvrtc.pyx.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. cimport cuda.bindings._bindings.cynvrtc as cynvrtc {{if 'nvrtcGetErrorString' in found_functions}} diff --git a/cuda_bindings/cuda/bindings/cynvvm.pxd b/cuda_bindings/cuda/bindings/cynvvm.pxd index d0f099609..cea1ce10f 100644 --- a/cuda_bindings/cuda/bindings/cynvvm.pxd +++ b/cuda_bindings/cuda/bindings/cynvvm.pxd @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 11.0.3 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 11.0.3 to 12.9.0. Do not modify it directly. ############################################################################### diff --git a/cuda_bindings/cuda/bindings/cynvvm.pyx b/cuda_bindings/cuda/bindings/cynvvm.pyx index 251fd5bf4..5c1a818bb 100644 --- a/cuda_bindings/cuda/bindings/cynvvm.pyx +++ b/cuda_bindings/cuda/bindings/cynvvm.pyx @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 11.0.3 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 11.0.3 to 12.9.0. Do not modify it directly. from ._internal cimport nvvm as _nvvm diff --git a/cuda_bindings/cuda/bindings/cyruntime.pxd.in b/cuda_bindings/cuda/bindings/cyruntime.pxd.in index a1703ad83..206089b58 100644 --- a/cuda_bindings/cuda/bindings/cyruntime.pxd.in +++ b/cuda_bindings/cuda/bindings/cyruntime.pxd.in @@ -6,1548 +6,11 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# 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 "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 - - 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 - cudaDevAttrGpuPciDeviceId = 139 - cudaDevAttrGpuPciSubsystemId = 140 - 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 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 +include "cyruntime_types.pxi" ctypedef unsigned int GLenum @@ -1578,14 +41,6 @@ ctypedef uint32_t VdpVideoSurface ctypedef uint32_t VdpOutputSurface -ctypedef cudaLaunchAttributeID cudaStreamAttrID - -ctypedef cudaLaunchAttributeID cudaKernelNodeAttrID - -ctypedef cudaLaunchAttributeValue cudaStreamAttrValue - -ctypedef cudaLaunchAttributeValue cudaKernelNodeAttrValue - cdef enum cudaEglFrameType_enum: cudaEglFrameTypeArray = 0 cudaEglFrameTypePitch = 1 @@ -3494,8 +1949,8 @@ cdef enum: cudaTextureType2DLayered = 242 cdef enum: cudaTextureTypeCubemapLayered = 252 -cdef enum: CUDART_VERSION = 12080 +cdef enum: CUDART_VERSION = 12090 -cdef enum: __CUDART_API_VERSION = 12080 +cdef enum: __CUDART_API_VERSION = 12090 cdef enum: CUDA_EGL_MAX_PLANES = 3 \ No newline at end of file diff --git a/cuda_bindings/cuda/bindings/cyruntime.pyx.in b/cuda_bindings/cuda/bindings/cyruntime.pyx.in index 979fcf910..f1dc2b549 100644 --- a/cuda_bindings/cuda/bindings/cyruntime.pyx.in +++ b/cuda_bindings/cuda/bindings/cyruntime.pyx.in @@ -6,10 +6,10 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. -cimport cython +# This code was automatically generated with version 12.9.0. Do not modify it directly. cimport cuda.bindings._bindings.cyruntime as cyruntime cimport cuda.bindings._lib.cyruntime.cyruntime as custom_cyruntime +cimport cython {{if 'cudaDeviceReset' in found_functions}} diff --git a/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in b/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in new file mode 100644 index 000000000..d323619ca --- /dev/null +++ b/cuda_bindings/cuda/bindings/cyruntime_functions.pxi.in @@ -0,0 +1,1493 @@ +# Copyright 2021-2025 NVIDIA Corporation. All rights reserved. +# +# Please refer to the NVIDIA end user license agreement (EULA) associated +# with this source code for terms and conditions that govern your use of +# this software. Any use, reproduction, disclosure, or distribution of +# this software and related documentation outside the terms of the EULA +# is strictly prohibited. +# +# This code was automatically generated with version 12.9.0. Do not modify it directly. +cdef extern from "cuda_runtime_api.h": + + {{if 'cudaDeviceReset' in found_functions}} + + cudaError_t cudaDeviceReset() nogil + + {{endif}} + {{if 'cudaDeviceSynchronize' in found_functions}} + + cudaError_t cudaDeviceSynchronize() nogil + + {{endif}} + {{if 'cudaDeviceSetLimit' in found_functions}} + + cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) nogil + + {{endif}} + {{if 'cudaDeviceGetLimit' in found_functions}} + + cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) nogil + + {{endif}} + {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} + + cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) nogil + + {{endif}} + {{if 'cudaDeviceGetCacheConfig' in found_functions}} + + cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) nogil + + {{endif}} + {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} + + cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) nogil + + {{endif}} + {{if 'cudaDeviceSetCacheConfig' in found_functions}} + + cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) nogil + + {{endif}} + {{if 'cudaDeviceGetByPCIBusId' in found_functions}} + + cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) nogil + + {{endif}} + {{if 'cudaDeviceGetPCIBusId' in found_functions}} + + cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) nogil + + {{endif}} + {{if 'cudaIpcGetEventHandle' in found_functions}} + + cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaIpcOpenEventHandle' in found_functions}} + + cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) nogil + + {{endif}} + {{if 'cudaIpcGetMemHandle' in found_functions}} + + cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) nogil + + {{endif}} + {{if 'cudaIpcOpenMemHandle' in found_functions}} + + cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) nogil + + {{endif}} + {{if 'cudaIpcCloseMemHandle' in found_functions}} + + cudaError_t cudaIpcCloseMemHandle(void* devPtr) nogil + + {{endif}} + {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} + + cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) nogil + + {{endif}} + {{if 'cudaDeviceRegisterAsyncNotification' in found_functions}} + + cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) nogil + + {{endif}} + {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} + + cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) nogil + + {{endif}} + {{if 'cudaDeviceGetSharedMemConfig' in found_functions}} + + cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) nogil + + {{endif}} + {{if 'cudaDeviceSetSharedMemConfig' in found_functions}} + + cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) nogil + + {{endif}} + {{if 'cudaGetLastError' in found_functions}} + + cudaError_t cudaGetLastError() nogil + + {{endif}} + {{if 'cudaPeekAtLastError' in found_functions}} + + cudaError_t cudaPeekAtLastError() nogil + + {{endif}} + {{if 'cudaGetErrorName' in found_functions}} + + const char* cudaGetErrorName(cudaError_t error) nogil + + {{endif}} + {{if 'cudaGetErrorString' in found_functions}} + + const char* cudaGetErrorString(cudaError_t error) nogil + + {{endif}} + {{if 'cudaGetDeviceCount' in found_functions}} + + cudaError_t cudaGetDeviceCount(int* count) nogil + + {{endif}} + {{if 'cudaGetDeviceProperties_v2' in found_functions}} + + cudaError_t cudaGetDeviceProperties_v2(cudaDeviceProp* prop, int device) nogil + + {{endif}} + {{if 'cudaDeviceGetAttribute' in found_functions}} + + cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) nogil + + {{endif}} + {{if 'cudaDeviceGetDefaultMemPool' in found_functions}} + + cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) nogil + + {{endif}} + {{if 'cudaDeviceSetMemPool' in found_functions}} + + cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) nogil + + {{endif}} + {{if 'cudaDeviceGetMemPool' in found_functions}} + + cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) nogil + + {{endif}} + {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} + + cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) nogil + + {{endif}} + {{if 'cudaDeviceGetP2PAttribute' in found_functions}} + + cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) nogil + + {{endif}} + {{if 'cudaChooseDevice' in found_functions}} + + cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) nogil + + {{endif}} + {{if 'cudaInitDevice' in found_functions}} + + cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) nogil + + {{endif}} + {{if 'cudaSetDevice' in found_functions}} + + cudaError_t cudaSetDevice(int device) nogil + + {{endif}} + {{if 'cudaGetDevice' in found_functions}} + + cudaError_t cudaGetDevice(int* device) nogil + + {{endif}} + {{if 'cudaSetDeviceFlags' in found_functions}} + + cudaError_t cudaSetDeviceFlags(unsigned int flags) nogil + + {{endif}} + {{if 'cudaGetDeviceFlags' in found_functions}} + + cudaError_t cudaGetDeviceFlags(unsigned int* flags) nogil + + {{endif}} + {{if 'cudaStreamCreate' in found_functions}} + + cudaError_t cudaStreamCreate(cudaStream_t* pStream) nogil + + {{endif}} + {{if 'cudaStreamCreateWithFlags' in found_functions}} + + cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) nogil + + {{endif}} + {{if 'cudaStreamCreateWithPriority' in found_functions}} + + cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) nogil + + {{endif}} + {{if 'cudaStreamGetPriority' in found_functions}} + + cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) nogil + + {{endif}} + {{if 'cudaStreamGetFlags' in found_functions}} + + cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) nogil + + {{endif}} + {{if 'cudaStreamGetId' in found_functions}} + + cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) nogil + + {{endif}} + {{if 'cudaStreamGetDevice' in found_functions}} + + cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) nogil + + {{endif}} + {{if 'cudaCtxResetPersistingL2Cache' in found_functions}} + + cudaError_t cudaCtxResetPersistingL2Cache() nogil + + {{endif}} + {{if 'cudaStreamCopyAttributes' in found_functions}} + + cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) nogil + + {{endif}} + {{if 'cudaStreamGetAttribute' in found_functions}} + + cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) nogil + + {{endif}} + {{if 'cudaStreamSetAttribute' in found_functions}} + + cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) nogil + + {{endif}} + {{if 'cudaStreamDestroy' in found_functions}} + + cudaError_t cudaStreamDestroy(cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaStreamWaitEvent' in found_functions}} + + cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) nogil + + {{endif}} + {{if 'cudaStreamAddCallback' in found_functions}} + + cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) nogil + + {{endif}} + {{if 'cudaStreamSynchronize' in found_functions}} + + cudaError_t cudaStreamSynchronize(cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaStreamQuery' in found_functions}} + + cudaError_t cudaStreamQuery(cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaStreamAttachMemAsync' in found_functions}} + + cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) nogil + + {{endif}} + {{if 'cudaStreamBeginCapture' in found_functions}} + + cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) nogil + + {{endif}} + {{if 'cudaStreamBeginCaptureToGraph' in found_functions}} + + cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) nogil + + {{endif}} + {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} + + cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) nogil + + {{endif}} + {{if 'cudaStreamEndCapture' in found_functions}} + + cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) nogil + + {{endif}} + {{if 'cudaStreamIsCapturing' in found_functions}} + + cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) nogil + + {{endif}} + {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaStreamGetCaptureInfo_v3' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}} + + cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) nogil + + {{endif}} + {{if 'cudaStreamUpdateCaptureDependencies_v2' in found_functions}} + + cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) nogil + + {{endif}} + {{if 'cudaEventCreate' in found_functions}} + + cudaError_t cudaEventCreate(cudaEvent_t* event) nogil + + {{endif}} + {{if 'cudaEventCreateWithFlags' in found_functions}} + + cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) nogil + + {{endif}} + {{if 'cudaEventRecord' in found_functions}} + + cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaEventRecordWithFlags' in found_functions}} + + cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) nogil + + {{endif}} + {{if 'cudaEventQuery' in found_functions}} + + cudaError_t cudaEventQuery(cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaEventSynchronize' in found_functions}} + + cudaError_t cudaEventSynchronize(cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaEventDestroy' in found_functions}} + + cudaError_t cudaEventDestroy(cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaEventElapsedTime' in found_functions}} + + cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) nogil + + {{endif}} + {{if 'cudaEventElapsedTime_v2' in found_functions}} + + cudaError_t cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) nogil + + {{endif}} + {{if 'cudaImportExternalMemory' in found_functions}} + + cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) nogil + + {{endif}} + {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} + + cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) nogil + + {{endif}} + {{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}} + + cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) nogil + + {{endif}} + {{if 'cudaDestroyExternalMemory' in found_functions}} + + cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) nogil + + {{endif}} + {{if 'cudaImportExternalSemaphore' in found_functions}} + + cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) nogil + + {{endif}} + {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}} + + cudaError_t cudaSignalExternalSemaphoresAsync_v2_ptsz(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}} + + cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}} + + cudaError_t cudaWaitExternalSemaphoresAsync_v2_ptsz(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}} + + cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaDestroyExternalSemaphore' in found_functions}} + + cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) nogil + + {{endif}} + {{if 'cudaFuncSetCacheConfig' in found_functions}} + + cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) nogil + + {{endif}} + {{if 'cudaFuncGetAttributes' in found_functions}} + + cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) nogil + + {{endif}} + {{if 'cudaFuncSetAttribute' in found_functions}} + + cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) nogil + + {{endif}} + {{if 'cudaLaunchHostFunc' in found_functions}} + + cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) nogil + + {{endif}} + {{if 'cudaFuncSetSharedMemConfig' in found_functions}} + + cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) nogil + + {{endif}} + {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} + + cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) nogil + + {{endif}} + {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} + + cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) nogil + + {{endif}} + {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}} + + cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) nogil + + {{endif}} + {{if 'cudaMallocManaged' in found_functions}} + + cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) nogil + + {{endif}} + {{if 'cudaMalloc' in found_functions}} + + cudaError_t cudaMalloc(void** devPtr, size_t size) nogil + + {{endif}} + {{if 'cudaMallocHost' in found_functions}} + + cudaError_t cudaMallocHost(void** ptr, size_t size) nogil + + {{endif}} + {{if 'cudaMallocPitch' in found_functions}} + + cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) nogil + + {{endif}} + {{if 'cudaMallocArray' in found_functions}} + + cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) nogil + + {{endif}} + {{if 'cudaFree' in found_functions}} + + cudaError_t cudaFree(void* devPtr) nogil + + {{endif}} + {{if 'cudaFreeHost' in found_functions}} + + cudaError_t cudaFreeHost(void* ptr) nogil + + {{endif}} + {{if 'cudaFreeArray' in found_functions}} + + cudaError_t cudaFreeArray(cudaArray_t array) nogil + + {{endif}} + {{if 'cudaFreeMipmappedArray' in found_functions}} + + cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) nogil + + {{endif}} + {{if 'cudaHostAlloc' in found_functions}} + + cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) nogil + + {{endif}} + {{if 'cudaHostRegister' in found_functions}} + + cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) nogil + + {{endif}} + {{if 'cudaHostUnregister' in found_functions}} + + cudaError_t cudaHostUnregister(void* ptr) nogil + + {{endif}} + {{if 'cudaHostGetDevicePointer' in found_functions}} + + cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) nogil + + {{endif}} + {{if 'cudaHostGetFlags' in found_functions}} + + cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) nogil + + {{endif}} + {{if 'cudaMalloc3D' in found_functions}} + + cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) nogil + + {{endif}} + {{if 'cudaMalloc3DArray' in found_functions}} + + cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) nogil + + {{endif}} + {{if 'cudaMallocMipmappedArray' in found_functions}} + + cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) nogil + + {{endif}} + {{if 'cudaGetMipmappedArrayLevel' in found_functions}} + + cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) nogil + + {{endif}} + {{if 'cudaMemcpy3D' in found_functions}} + + cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) nogil + + {{endif}} + {{if 'cudaMemcpy3DPeer' in found_functions}} + + cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) nogil + + {{endif}} + {{if 'cudaMemcpy3DAsync' in found_functions}} + + cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemcpy3DPeerAsync' in found_functions}} + + cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemGetInfo' in found_functions}} + + cudaError_t cudaMemGetInfo(size_t* free, size_t* total) nogil + + {{endif}} + {{if 'cudaArrayGetInfo' in found_functions}} + + cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) nogil + + {{endif}} + {{if 'cudaArrayGetPlane' in found_functions}} + + cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) nogil + + {{endif}} + {{if 'cudaArrayGetMemoryRequirements' in found_functions}} + + cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) nogil + + {{endif}} + {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} + + cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) nogil + + {{endif}} + {{if 'cudaArrayGetSparseProperties' in found_functions}} + + cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) nogil + + {{endif}} + {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} + + cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) nogil + + {{endif}} + {{if 'cudaMemcpy' in found_functions}} + + cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil + + {{endif}} + {{if 'cudaMemcpyPeer' in found_functions}} + + cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) nogil + + {{endif}} + {{if 'cudaMemcpy2D' in found_functions}} + + cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) nogil + + {{endif}} + {{if 'cudaMemcpy2DToArray' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaMemcpy2DFromArray' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaMemcpy2DArrayToArray' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaMemcpyAsync' in found_functions}} + + cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemcpyPeerAsync' in found_functions}} + + cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemcpyBatchAsync' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaMemcpy3DBatchAsync' in found_functions}} + + cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemcpy2DAsync' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaMemcpy2DToArrayAsync' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaMemcpy2DFromArrayAsync' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaMemset' in found_functions}} + + cudaError_t cudaMemset(void* devPtr, int value, size_t count) nogil + + {{endif}} + {{if 'cudaMemset2D' in found_functions}} + + cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) nogil + + {{endif}} + {{if 'cudaMemset3D' in found_functions}} + + cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) nogil + + {{endif}} + {{if 'cudaMemsetAsync' in found_functions}} + + cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemset2DAsync' in found_functions}} + + cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemset3DAsync' in found_functions}} + + cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemPrefetchAsync' in found_functions}} + + cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemPrefetchAsync_v2' in found_functions}} + + cudaError_t cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemAdvise' in found_functions}} + + cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) nogil + + {{endif}} + {{if 'cudaMemAdvise_v2' in found_functions}} + + cudaError_t cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) nogil + + {{endif}} + {{if 'cudaMemRangeGetAttribute' in found_functions}} + + cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) nogil + + {{endif}} + {{if 'cudaMemRangeGetAttributes' in found_functions}} + + cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) nogil + + {{endif}} + {{if 'cudaMemcpyToArray' in found_functions}} + + cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) nogil + + {{endif}} + {{if 'cudaMemcpyFromArray' in found_functions}} + + cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) nogil + + {{endif}} + {{if 'cudaMemcpyArrayToArray' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaMemcpyToArrayAsync' in found_functions}} + + cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemcpyFromArrayAsync' in found_functions}} + + cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMallocAsync' in found_functions}} + + cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) nogil + + {{endif}} + {{if 'cudaFreeAsync' in found_functions}} + + cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) nogil + + {{endif}} + {{if 'cudaMemPoolTrimTo' in found_functions}} + + cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) nogil + + {{endif}} + {{if 'cudaMemPoolSetAttribute' in found_functions}} + + cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) nogil + + {{endif}} + {{if 'cudaMemPoolGetAttribute' in found_functions}} + + cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) nogil + + {{endif}} + {{if 'cudaMemPoolSetAccess' in found_functions}} + + cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) nogil + + {{endif}} + {{if 'cudaMemPoolGetAccess' in found_functions}} + + cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) nogil + + {{endif}} + {{if 'cudaMemPoolCreate' in found_functions}} + + cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) nogil + + {{endif}} + {{if 'cudaMemPoolDestroy' in found_functions}} + + cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) nogil + + {{endif}} + {{if 'cudaMallocFromPoolAsync' in found_functions}} + + cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaMemPoolExportToShareableHandle' in found_functions}} + + cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) nogil + + {{endif}} + {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}} + + cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) nogil + + {{endif}} + {{if 'cudaMemPoolExportPointer' in found_functions}} + + cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) nogil + + {{endif}} + {{if 'cudaMemPoolImportPointer' in found_functions}} + + cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) nogil + + {{endif}} + {{if 'cudaPointerGetAttributes' in found_functions}} + + cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) nogil + + {{endif}} + {{if 'cudaDeviceCanAccessPeer' in found_functions}} + + cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) nogil + + {{endif}} + {{if 'cudaDeviceEnablePeerAccess' in found_functions}} + + cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) nogil + + {{endif}} + {{if 'cudaDeviceDisablePeerAccess' in found_functions}} + + cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) nogil + + {{endif}} + {{if 'cudaGraphicsUnregisterResource' in found_functions}} + + cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) nogil + + {{endif}} + {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} + + cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) nogil + + {{endif}} + {{if 'cudaGraphicsMapResources' in found_functions}} + + cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaGraphicsUnmapResources' in found_functions}} + + cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} + + cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) nogil + + {{endif}} + {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}} + + cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) nogil + + {{endif}} + {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} + + cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) nogil + + {{endif}} + {{if 'cudaGetChannelDesc' in found_functions}} + + cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) nogil + + {{endif}} + {{if 'cudaCreateChannelDesc' in found_functions}} + + cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) nogil + + {{endif}} + {{if 'cudaCreateTextureObject' in found_functions}} + + cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) nogil + + {{endif}} + {{if 'cudaDestroyTextureObject' in found_functions}} + + cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) nogil + + {{endif}} + {{if 'cudaGetTextureObjectResourceDesc' in found_functions}} + + cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) nogil + + {{endif}} + {{if 'cudaGetTextureObjectTextureDesc' in found_functions}} + + cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) nogil + + {{endif}} + {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} + + cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) nogil + + {{endif}} + {{if 'cudaCreateSurfaceObject' in found_functions}} + + cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) nogil + + {{endif}} + {{if 'cudaDestroySurfaceObject' in found_functions}} + + cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) nogil + + {{endif}} + {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} + + cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) nogil + + {{endif}} + {{if 'cudaDriverGetVersion' in found_functions}} + + cudaError_t cudaDriverGetVersion(int* driverVersion) nogil + + {{endif}} + {{if 'cudaRuntimeGetVersion' in found_functions}} + + cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) nogil + + {{endif}} + {{if 'cudaGraphCreate' in found_functions}} + + cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) nogil + + {{endif}} + {{if 'cudaGraphAddKernelNode' in found_functions}} + + cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphKernelNodeGetParams' in found_functions}} + + cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphKernelNodeSetParams' in found_functions}} + + cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} + + cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) nogil + + {{endif}} + {{if 'cudaGraphKernelNodeGetAttribute' in found_functions}} + + cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) nogil + + {{endif}} + {{if 'cudaGraphKernelNodeSetAttribute' in found_functions}} + + cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) nogil + + {{endif}} + {{if 'cudaGraphAddMemcpyNode' in found_functions}} + + cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) nogil + + {{endif}} + {{if 'cudaGraphAddMemcpyNode1D' in found_functions}} + + 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 + + {{endif}} + {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} + + cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} + + cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}} + + cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil + + {{endif}} + {{if 'cudaGraphAddMemsetNode' in found_functions}} + + cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) nogil + + {{endif}} + {{if 'cudaGraphMemsetNodeGetParams' in found_functions}} + + cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphMemsetNodeSetParams' in found_functions}} + + cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphAddHostNode' in found_functions}} + + cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphHostNodeGetParams' in found_functions}} + + cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphHostNodeSetParams' in found_functions}} + + cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphAddChildGraphNode' in found_functions}} + + cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) nogil + + {{endif}} + {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} + + cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) nogil + + {{endif}} + {{if 'cudaGraphAddEmptyNode' in found_functions}} + + cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) nogil + + {{endif}} + {{if 'cudaGraphAddEventRecordNode' in found_functions}} + + cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} + + cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) nogil + + {{endif}} + {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} + + cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaGraphAddEventWaitNode' in found_functions}} + + cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} + + cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) nogil + + {{endif}} + {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} + + cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}} + + cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} + + cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) nogil + + {{endif}} + {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}} + + cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} + + cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) nogil + + {{endif}} + {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphAddMemAllocNode' in found_functions}} + + cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} + + cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) nogil + + {{endif}} + {{if 'cudaGraphAddMemFreeNode' in found_functions}} + + cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) nogil + + {{endif}} + {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} + + cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) nogil + + {{endif}} + {{if 'cudaDeviceGraphMemTrim' in found_functions}} + + cudaError_t cudaDeviceGraphMemTrim(int device) nogil + + {{endif}} + {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} + + cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) nogil + + {{endif}} + {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} + + cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) nogil + + {{endif}} + {{if 'cudaGraphClone' in found_functions}} + + cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) nogil + + {{endif}} + {{if 'cudaGraphNodeFindInClone' in found_functions}} + + cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) nogil + + {{endif}} + {{if 'cudaGraphNodeGetType' in found_functions}} + + cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) nogil + + {{endif}} + {{if 'cudaGraphGetNodes' in found_functions}} + + cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) nogil + + {{endif}} + {{if 'cudaGraphGetRootNodes' in found_functions}} + + cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) nogil + + {{endif}} + {{if 'cudaGraphGetEdges' in found_functions}} + + cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) nogil + + {{endif}} + {{if 'cudaGraphGetEdges_v2' in found_functions}} + + cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) nogil + + {{endif}} + {{if 'cudaGraphNodeGetDependencies' in found_functions}} + + cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) nogil + + {{endif}} + {{if 'cudaGraphNodeGetDependencies_v2' in found_functions}} + + cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) nogil + + {{endif}} + {{if 'cudaGraphNodeGetDependentNodes' in found_functions}} + + cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) nogil + + {{endif}} + {{if 'cudaGraphNodeGetDependentNodes_v2' in found_functions}} + + cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) nogil + + {{endif}} + {{if 'cudaGraphAddDependencies' in found_functions}} + + cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) nogil + + {{endif}} + {{if 'cudaGraphAddDependencies_v2' in found_functions}} + + cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) nogil + + {{endif}} + {{if 'cudaGraphRemoveDependencies' in found_functions}} + + cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) nogil + + {{endif}} + {{if 'cudaGraphRemoveDependencies_v2' in found_functions}} + + cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) nogil + + {{endif}} + {{if 'cudaGraphDestroyNode' in found_functions}} + + cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) nogil + + {{endif}} + {{if 'cudaGraphInstantiate' in found_functions}} + + cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) nogil + + {{endif}} + {{if 'cudaGraphInstantiateWithFlags' in found_functions}} + + cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) nogil + + {{endif}} + {{if 'cudaGraphInstantiateWithParams' in found_functions}} + + cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) nogil + + {{endif}} + {{if 'cudaGraphExecGetFlags' in found_functions}} + + cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) nogil + + {{endif}} + {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}} + + cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) nogil + + {{endif}} + {{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphExecHostNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) nogil + + {{endif}} + {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) nogil + + {{endif}} + {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}} + + cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}} + + cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) nogil + + {{endif}} + {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphNodeSetEnabled' in found_functions}} + + cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) nogil + + {{endif}} + {{if 'cudaGraphNodeGetEnabled' in found_functions}} + + cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) nogil + + {{endif}} + {{if 'cudaGraphExecUpdate' in found_functions}} + + cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) nogil + + {{endif}} + {{if 'cudaGraphUpload' in found_functions}} + + cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaGraphLaunch' in found_functions}} + + cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) nogil + + {{endif}} + {{if 'cudaGraphExecDestroy' in found_functions}} + + cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) nogil + + {{endif}} + {{if 'cudaGraphDestroy' in found_functions}} + + cudaError_t cudaGraphDestroy(cudaGraph_t graph) nogil + + {{endif}} + {{if 'cudaGraphDebugDotPrint' in found_functions}} + + cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) nogil + + {{endif}} + {{if 'cudaUserObjectCreate' in found_functions}} + + cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) nogil + + {{endif}} + {{if 'cudaUserObjectRetain' in found_functions}} + + cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) nogil + + {{endif}} + {{if 'cudaUserObjectRelease' in found_functions}} + + cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) nogil + + {{endif}} + {{if 'cudaGraphRetainUserObject' in found_functions}} + + cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) nogil + + {{endif}} + {{if 'cudaGraphReleaseUserObject' in found_functions}} + + cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) nogil + + {{endif}} + {{if 'cudaGraphAddNode' in found_functions}} + + cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphAddNode_v2' in found_functions}} + + cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphNodeSetParams' in found_functions}} + + cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphExecNodeSetParams' in found_functions}} + + cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) nogil + + {{endif}} + {{if 'cudaGraphConditionalHandleCreate' in found_functions}} + + cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) nogil + + {{endif}} + {{if 'cudaGetDriverEntryPoint' in found_functions}} + + cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) nogil + + {{endif}} + {{if 'cudaGetDriverEntryPointByVersion' in found_functions}} + + cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) nogil + + {{endif}} + {{if 'cudaLibraryLoadData' in found_functions}} + + cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) nogil + + {{endif}} + {{if 'cudaLibraryLoadFromFile' in found_functions}} + + cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) nogil + + {{endif}} + {{if 'cudaLibraryUnload' in found_functions}} + + cudaError_t cudaLibraryUnload(cudaLibrary_t library) nogil + + {{endif}} + {{if 'cudaLibraryGetKernel' in found_functions}} + + cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) nogil + + {{endif}} + {{if 'cudaLibraryGetGlobal' in found_functions}} + + cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) nogil + + {{endif}} + {{if 'cudaLibraryGetManaged' in found_functions}} + + cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) nogil + + {{endif}} + {{if 'cudaLibraryGetUnifiedFunction' in found_functions}} + + cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) nogil + + {{endif}} + {{if 'cudaLibraryGetKernelCount' in found_functions}} + + cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) nogil + + {{endif}} + {{if 'cudaLibraryEnumerateKernels' in found_functions}} + + cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) nogil + + {{endif}} + {{if 'cudaKernelSetAttributeForDevice' in found_functions}} + + cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) nogil + + {{endif}} + {{if 'cudaGetExportTable' in found_functions}} + + cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) nogil + + {{endif}} + {{if 'cudaGetKernel' in found_functions}} + + cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) nogil + + {{endif}} + +cdef extern from "cuda_runtime.h": + + {{if 'make_cudaPitchedPtr' in found_functions}} + + cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) nogil + + {{endif}} + {{if 'make_cudaPos' in found_functions}} + + cudaPos make_cudaPos(size_t x, size_t y, size_t z) nogil + + {{endif}} + {{if 'make_cudaExtent' in found_functions}} + + cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) nogil + + {{endif}} + +cdef extern from "cuda_profiler_api.h": + + {{if 'cudaProfilerStart' in found_functions}} + + cudaError_t cudaProfilerStart() nogil + + {{endif}} + {{if 'cudaProfilerStop' in found_functions}} + + cudaError_t cudaProfilerStop() nogil + + {{endif}} + diff --git a/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in b/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in new file mode 100644 index 000000000..3198ce2bd --- /dev/null +++ b/cuda_bindings/cuda/bindings/cyruntime_types.pxi.in @@ -0,0 +1,1564 @@ +# Copyright 2021-2025 NVIDIA Corporation. All rights reserved. +# +# Please refer to the NVIDIA end user license agreement (EULA) associated +# with this source code for terms and conditions that govern your use of +# this software. Any use, reproduction, disclosure, or distribution of +# this software and related documentation outside the terms of the EULA +# is strictly prohibited. +# +# 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 diff --git a/cuda_bindings/cuda/bindings/driver.pxd.in b/cuda_bindings/cuda/bindings/driver.pxd.in index 1959f67fe..c45c34da0 100644 --- a/cuda_bindings/cuda/bindings/driver.pxd.in +++ b/cuda_bindings/cuda/bindings/driver.pxd.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. cimport cuda.bindings.cydriver as cydriver cimport cuda.bindings._lib.utils as utils @@ -417,6 +417,21 @@ cdef class CUdevResourceDesc: cdef cydriver.CUdevResourceDesc* _pvt_ptr {{endif}} +{{if 'CUlogsCallbackHandle' in found_types}} + +cdef class CUlogsCallbackHandle: + """ + + Methods + ------- + getPtr() + Get memory address of class instance + + """ + cdef cydriver.CUlogsCallbackHandle _pvt_val + cdef cydriver.CUlogsCallbackHandle* _pvt_ptr +{{endif}} + {{if True}} cdef class CUeglStreamConnection: @@ -539,6 +554,21 @@ cdef class CUoccupancyB2DSize: cdef cydriver.CUoccupancyB2DSize* _pvt_ptr {{endif}} +{{if 'CUlogsCallback' in found_types}} + +cdef class CUlogsCallback: + """ + + Methods + ------- + getPtr() + Get memory address of class instance + + """ + cdef cydriver.CUlogsCallback _pvt_val + cdef cydriver.CUlogsCallback* _pvt_ptr +{{endif}} + {{if 'CUuuid_st' in found_struct}} cdef class CUuuid_st: @@ -758,7 +788,7 @@ cdef class CUstreamMemOpMemoryBarrierParams_st: {{endif}} {{if 'CUstreamBatchMemOpParams_union.memoryBarrier.flags' in found_struct}} flags : unsigned int - + See CUstreamMemoryBarrier_flags {{endif}} Methods @@ -948,11 +978,12 @@ cdef class CUasyncNotificationInfo_st: ---------- {{if 'CUasyncNotificationInfo_st.type' in found_struct}} type : CUasyncNotificationType - + The type of notification being sent {{endif}} {{if 'CUasyncNotificationInfo_st.info' in found_struct}} info : anon_union2 - + Information about the notification. `typename` must be checked in + order to interpret this field. {{endif}} Methods @@ -4343,37 +4374,33 @@ cdef class CUmemPoolPtrExportData_st: cdef cydriver.CUmemPoolPtrExportData_st _pvt_val cdef cydriver.CUmemPoolPtrExportData_st* _pvt_ptr {{endif}} -{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st' in found_struct}} +{{if 'CUmemcpyAttributes_st' in found_struct}} -cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1_st: +cdef class CUmemcpyAttributes_st: """ - Memory allocation node parameters + Attributes specific to copies within a batch. For more details on + usage see cuMemcpyBatchAsync. Attributes ---------- - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} - poolProps : CUmemPoolProps - in: location where the allocation should reside (specified in - ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is - not supported. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} - accessDescs : CUmemAccessDesc - in: array of memory access descriptors. Used to describe peer GPU - access + {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} + srcAccessOrder : CUmemcpySrcAccessOrder + Source access ordering to be observed for copies with this + attribute. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} - accessDescCount : size_t - in: number of memory access descriptors. Must not exceed the number - of GPUs. + {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} + srcLocHint : CUmemLocation + Hint location for the source operand. Ignored when the pointers are + not managed memory or memory allocated outside CUDA. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} - bytesize : size_t - in: size in bytes of the requested allocation + {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} + dstLocHint : CUmemLocation + Hint location for the destination operand. Ignored when the + pointers are not managed memory or memory allocated outside CUDA. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} - dptr : CUdeviceptr - out: address of the allocation returned by CUDA + {{if 'CUmemcpyAttributes_st.flags' in found_struct}} + flags : unsigned int + Additional flags for copies with this attribute. See CUmemcpyFlags {{endif}} Methods @@ -4381,50 +4408,34 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v1_st _pvt_val - cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v1_st* _pvt_ptr - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} - cdef CUmemPoolProps _poolProps - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} - cdef size_t _accessDescs_length - cdef cydriver.CUmemAccessDesc* _accessDescs + cdef cydriver.CUmemcpyAttributes_st _pvt_val + cdef cydriver.CUmemcpyAttributes_st* _pvt_ptr + {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} + cdef CUmemLocation _srcLocHint {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} - cdef CUdeviceptr _dptr + {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} + cdef CUmemLocation _dstLocHint {{endif}} {{endif}} -{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st' in found_struct}} +{{if 'CUoffset3D_st' in found_struct}} -cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2_st: +cdef class CUoffset3D_st: """ - Memory allocation node parameters + Struct representing offset into a CUarray in elements Attributes ---------- - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} - poolProps : CUmemPoolProps - in: location where the allocation should reside (specified in - ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is - not supported. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} - accessDescs : CUmemAccessDesc - in: array of memory access descriptors. Used to describe peer GPU - access - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} - accessDescCount : size_t - in: number of memory access descriptors. Must not exceed the number - of GPUs. + {{if 'CUoffset3D_st.x' in found_struct}} + x : size_t + {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} - bytesize : size_t - in: size in bytes of the requested allocation + {{if 'CUoffset3D_st.y' in found_struct}} + y : size_t + {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} - dptr : CUdeviceptr - out: address of the allocation returned by CUDA + {{if 'CUoffset3D_st.z' in found_struct}} + z : size_t + {{endif}} Methods @@ -4432,30 +4443,28 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v2_st _pvt_val - cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v2_st* _pvt_ptr - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} - cdef CUmemPoolProps _poolProps - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} - cdef size_t _accessDescs_length - cdef cydriver.CUmemAccessDesc* _accessDescs - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} - cdef CUdeviceptr _dptr - {{endif}} + cdef cydriver.CUoffset3D_st _pvt_val + cdef cydriver.CUoffset3D_st* _pvt_ptr {{endif}} -{{if 'CUDA_MEM_FREE_NODE_PARAMS_st' in found_struct}} +{{if 'CUextent3D_st' in found_struct}} -cdef class CUDA_MEM_FREE_NODE_PARAMS_st: +cdef class CUextent3D_st: """ - Memory free node parameters + Struct representing width/height/depth of a CUarray in elements Attributes ---------- - {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} - dptr : CUdeviceptr - in: the pointer to free + {{if 'CUextent3D_st.width' in found_struct}} + width : size_t + + {{endif}} + {{if 'CUextent3D_st.height' in found_struct}} + height : size_t + + {{endif}} + {{if 'CUextent3D_st.depth' in found_struct}} + depth : size_t + {{endif}} Methods @@ -4463,24 +4472,30 @@ cdef class CUDA_MEM_FREE_NODE_PARAMS_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUDA_MEM_FREE_NODE_PARAMS_st _pvt_val - cdef cydriver.CUDA_MEM_FREE_NODE_PARAMS_st* _pvt_ptr - {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} - cdef CUdeviceptr _dptr - {{endif}} + cdef cydriver.CUextent3D_st _pvt_val + cdef cydriver.CUextent3D_st* _pvt_ptr {{endif}} -{{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st' in found_struct}} +{{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} -cdef class CUDA_CHILD_GRAPH_NODE_PARAMS_st: +cdef class anon_struct23: """ - Child graph node parameters - Attributes ---------- - {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} - graph : CUgraph - The child graph to clone into the node for node creation, or a - handle to the graph owned by the node for node query + {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} + ptr : CUdeviceptr + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.rowLength' in found_struct}} + rowLength : size_t + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.layerHeight' in found_struct}} + layerHeight : size_t + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} + locHint : CUmemLocation + {{endif}} Methods @@ -4488,23 +4503,27 @@ cdef class CUDA_CHILD_GRAPH_NODE_PARAMS_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUDA_CHILD_GRAPH_NODE_PARAMS_st _pvt_val - cdef cydriver.CUDA_CHILD_GRAPH_NODE_PARAMS_st* _pvt_ptr - {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} - cdef CUgraph _graph + cdef cydriver.CUmemcpy3DOperand_st* _pvt_ptr + {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} + cdef CUdeviceptr _ptr + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} + cdef CUmemLocation _locHint {{endif}} {{endif}} -{{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st' in found_struct}} +{{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} -cdef class CUDA_EVENT_RECORD_NODE_PARAMS_st: +cdef class anon_struct24: """ - Event record node parameters - Attributes ---------- - {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} - event : CUevent - The event to record when the node executes + {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} + array : CUarray + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} + offset : CUoffset3D + {{endif}} Methods @@ -4512,23 +4531,27 @@ cdef class CUDA_EVENT_RECORD_NODE_PARAMS_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUDA_EVENT_RECORD_NODE_PARAMS_st _pvt_val - cdef cydriver.CUDA_EVENT_RECORD_NODE_PARAMS_st* _pvt_ptr - {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} - cdef CUevent _event + cdef cydriver.CUmemcpy3DOperand_st* _pvt_ptr + {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} + cdef CUarray _array + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} + cdef CUoffset3D _offset {{endif}} {{endif}} -{{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st' in found_struct}} +{{if 'CUmemcpy3DOperand_st.op' in found_struct}} -cdef class CUDA_EVENT_WAIT_NODE_PARAMS_st: +cdef class anon_union12: """ - Event wait node parameters - Attributes ---------- - {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} - event : CUevent - The event to wait on from the node + {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} + ptr : anon_struct23 + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} + array : anon_struct24 + {{endif}} Methods @@ -4536,87 +4559,29 @@ cdef class CUDA_EVENT_WAIT_NODE_PARAMS_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUDA_EVENT_WAIT_NODE_PARAMS_st _pvt_val - cdef cydriver.CUDA_EVENT_WAIT_NODE_PARAMS_st* _pvt_ptr - {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} - cdef CUevent _event + cdef cydriver.CUmemcpy3DOperand_st* _pvt_ptr + {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} + cdef anon_struct23 _ptr + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} + cdef anon_struct24 _array {{endif}} {{endif}} -{{if 'CUgraphNodeParams_st' in found_struct}} +{{if 'CUmemcpy3DOperand_st' in found_struct}} -cdef class CUgraphNodeParams_st: +cdef class CUmemcpy3DOperand_st: """ - Graph node parameters. See cuGraphAddNode. + Struct representing an operand for copy with cuMemcpy3DBatchAsync Attributes ---------- - {{if 'CUgraphNodeParams_st.type' in found_struct}} - type : CUgraphNodeType - Type of the node - {{endif}} - {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} - reserved0 : List[int] - Reserved. Must be zero. - {{endif}} - {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} - reserved1 : List[long long] - Padding. Unused bytes must be zero. - {{endif}} - {{if 'CUgraphNodeParams_st.kernel' in found_struct}} - kernel : CUDA_KERNEL_NODE_PARAMS_v3 - Kernel node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} - memcpy : CUDA_MEMCPY_NODE_PARAMS - Memcpy node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memset' in found_struct}} - memset : CUDA_MEMSET_NODE_PARAMS_v2 - Memset node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.host' in found_struct}} - host : CUDA_HOST_NODE_PARAMS_v2 - Host node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.graph' in found_struct}} - graph : CUDA_CHILD_GRAPH_NODE_PARAMS - Child graph node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} - eventWait : CUDA_EVENT_WAIT_NODE_PARAMS - Event wait node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} - eventRecord : CUDA_EVENT_RECORD_NODE_PARAMS - Event record node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} - extSemSignal : CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 - External semaphore signal node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} - extSemWait : CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 - External semaphore wait node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.alloc' in found_struct}} - alloc : CUDA_MEM_ALLOC_NODE_PARAMS_v2 - Memory allocation node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.free' in found_struct}} - free : CUDA_MEM_FREE_NODE_PARAMS - Memory free node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memOp' in found_struct}} - memOp : CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 - MemOp node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.conditional' in found_struct}} - conditional : CUDA_CONDITIONAL_NODE_PARAMS - Conditional node parameters. + {{if 'CUmemcpy3DOperand_st.type' in found_struct}} + type : CUmemcpy3DOperandType + {{endif}} - {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} - reserved2 : long long - Reserved bytes. Must be zero. + {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + op : anon_union12 + {{endif}} Methods @@ -4624,68 +4589,38 @@ cdef class CUgraphNodeParams_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUgraphNodeParams_st* _val_ptr - cdef cydriver.CUgraphNodeParams_st* _pvt_ptr - {{if 'CUgraphNodeParams_st.kernel' in found_struct}} - cdef CUDA_KERNEL_NODE_PARAMS_v3 _kernel - {{endif}} - {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} - cdef CUDA_MEMCPY_NODE_PARAMS _memcpy - {{endif}} - {{if 'CUgraphNodeParams_st.memset' in found_struct}} - cdef CUDA_MEMSET_NODE_PARAMS_v2 _memset - {{endif}} - {{if 'CUgraphNodeParams_st.host' in found_struct}} - cdef CUDA_HOST_NODE_PARAMS_v2 _host - {{endif}} - {{if 'CUgraphNodeParams_st.graph' in found_struct}} - cdef CUDA_CHILD_GRAPH_NODE_PARAMS _graph - {{endif}} - {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} - cdef CUDA_EVENT_WAIT_NODE_PARAMS _eventWait - {{endif}} - {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} - cdef CUDA_EVENT_RECORD_NODE_PARAMS _eventRecord - {{endif}} - {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} - cdef CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 _extSemSignal - {{endif}} - {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} - cdef CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 _extSemWait - {{endif}} - {{if 'CUgraphNodeParams_st.alloc' in found_struct}} - cdef CUDA_MEM_ALLOC_NODE_PARAMS_v2 _alloc - {{endif}} - {{if 'CUgraphNodeParams_st.free' in found_struct}} - cdef CUDA_MEM_FREE_NODE_PARAMS _free - {{endif}} - {{if 'CUgraphNodeParams_st.memOp' in found_struct}} - cdef CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 _memOp - {{endif}} - {{if 'CUgraphNodeParams_st.conditional' in found_struct}} - cdef CUDA_CONDITIONAL_NODE_PARAMS _conditional + cdef cydriver.CUmemcpy3DOperand_st* _val_ptr + cdef cydriver.CUmemcpy3DOperand_st* _pvt_ptr + {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + cdef anon_union12 _op {{endif}} {{endif}} -{{if 'CUcheckpointLockArgs_st' in found_struct}} +{{if 'CUDA_MEMCPY3D_BATCH_OP_st' in found_struct}} -cdef class CUcheckpointLockArgs_st: +cdef class CUDA_MEMCPY3D_BATCH_OP_st: """ - CUDA checkpoint optional lock arguments - Attributes ---------- - {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} - timeoutMs : unsigned int - Timeout in milliseconds to attempt to lock the process, 0 indicates - no timeout + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} + src : CUmemcpy3DOperand + Source memcpy operand. {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} - reserved0 : unsigned int - Reserved for future use, must be zero + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} + dst : CUmemcpy3DOperand + Destination memcpy operand. {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} - reserved1 : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} + extent : CUextent3D + Extents of the memcpy between src and dst. The width, height and + depth components must not be 0. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} + srcAccessOrder : CUmemcpySrcAccessOrder + Source access ordering to be observed for copy from src to dst. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} + flags : unsigned int + Additional flags for copies with this attribute. See CUmemcpyFlags {{endif}} Methods @@ -4693,20 +4628,49 @@ cdef class CUcheckpointLockArgs_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUcheckpointLockArgs_st _pvt_val - cdef cydriver.CUcheckpointLockArgs_st* _pvt_ptr + cdef cydriver.CUDA_MEMCPY3D_BATCH_OP_st _pvt_val + cdef cydriver.CUDA_MEMCPY3D_BATCH_OP_st* _pvt_ptr + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} + cdef CUmemcpy3DOperand _src + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} + cdef CUmemcpy3DOperand _dst + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} + cdef CUextent3D _extent + {{endif}} {{endif}} -{{if 'CUcheckpointCheckpointArgs_st' in found_struct}} +{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st' in found_struct}} -cdef class CUcheckpointCheckpointArgs_st: +cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1_st: """ - CUDA checkpoint optional checkpoint arguments + Memory allocation node parameters Attributes ---------- - {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} + poolProps : CUmemPoolProps + in: location where the allocation should reside (specified in + ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is + not supported. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + accessDescs : CUmemAccessDesc + in: array of memory access descriptors. Used to describe peer GPU + access + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} + accessDescCount : size_t + in: number of memory access descriptors. Must not exceed the number + of GPUs. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} + bytesize : size_t + in: size in bytes of the requested allocation + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + dptr : CUdeviceptr + out: address of the allocation returned by CUDA {{endif}} Methods @@ -4714,20 +4678,50 @@ cdef class CUcheckpointCheckpointArgs_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUcheckpointCheckpointArgs_st _pvt_val - cdef cydriver.CUcheckpointCheckpointArgs_st* _pvt_ptr + cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v1_st _pvt_val + cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v1_st* _pvt_ptr + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} + cdef CUmemPoolProps _poolProps + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + cdef size_t _accessDescs_length + cdef cydriver.CUmemAccessDesc* _accessDescs + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + cdef CUdeviceptr _dptr + {{endif}} {{endif}} -{{if 'CUcheckpointRestoreArgs_st' in found_struct}} +{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st' in found_struct}} -cdef class CUcheckpointRestoreArgs_st: +cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2_st: """ - CUDA checkpoint optional restore arguments + Memory allocation node parameters Attributes ---------- - {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} + poolProps : CUmemPoolProps + in: location where the allocation should reside (specified in + ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is + not supported. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} + accessDescs : CUmemAccessDesc + in: array of memory access descriptors. Used to describe peer GPU + access + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} + accessDescCount : size_t + in: number of memory access descriptors. Must not exceed the number + of GPUs. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} + bytesize : size_t + in: size in bytes of the requested allocation + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + dptr : CUdeviceptr + out: address of the allocation returned by CUDA {{endif}} Methods @@ -4735,20 +4729,30 @@ cdef class CUcheckpointRestoreArgs_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUcheckpointRestoreArgs_st _pvt_val - cdef cydriver.CUcheckpointRestoreArgs_st* _pvt_ptr + cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v2_st _pvt_val + cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v2_st* _pvt_ptr + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} + cdef CUmemPoolProps _poolProps + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} + cdef size_t _accessDescs_length + cdef cydriver.CUmemAccessDesc* _accessDescs + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + cdef CUdeviceptr _dptr + {{endif}} {{endif}} -{{if 'CUcheckpointUnlockArgs_st' in found_struct}} +{{if 'CUDA_MEM_FREE_NODE_PARAMS_st' in found_struct}} -cdef class CUcheckpointUnlockArgs_st: +cdef class CUDA_MEM_FREE_NODE_PARAMS_st: """ - CUDA checkpoint optional unlock arguments + Memory free node parameters Attributes ---------- - {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} + dptr : CUdeviceptr + in: the pointer to free {{endif}} Methods @@ -4756,36 +4760,31 @@ cdef class CUcheckpointUnlockArgs_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUcheckpointUnlockArgs_st _pvt_val - cdef cydriver.CUcheckpointUnlockArgs_st* _pvt_ptr + cdef cydriver.CUDA_MEM_FREE_NODE_PARAMS_st _pvt_val + cdef cydriver.CUDA_MEM_FREE_NODE_PARAMS_st* _pvt_ptr + {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} + cdef CUdeviceptr _dptr + {{endif}} {{endif}} -{{if 'CUmemcpyAttributes_st' in found_struct}} +{{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st' in found_struct}} -cdef class CUmemcpyAttributes_st: +cdef class CUDA_CHILD_GRAPH_NODE_PARAMS_st: """ - Attributes specific to copies within a batch. For more details on - usage see cuMemcpyBatchAsync. + Child graph node parameters Attributes ---------- - {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} - srcAccessOrder : CUmemcpySrcAccessOrder - Source access ordering to be observed for copies with this - attribute. - {{endif}} - {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} - srcLocHint : CUmemLocation - Hint location for the source operand. Ignored when the pointers are - not managed memory or memory allocated outside CUDA. - {{endif}} - {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} - dstLocHint : CUmemLocation - Hint location for the destination operand. Ignored when the - pointers are not managed memory or memory allocated outside CUDA. + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} + graph : CUgraph + The child graph to clone into the node for node creation, or a + handle to the graph owned by the node for node query. The graph + must not contain conditional nodes. Graphs containing memory + allocation or memory free nodes must set the ownership to be moved + to the parent. {{endif}} - {{if 'CUmemcpyAttributes_st.flags' in found_struct}} - flags : unsigned int - Additional flags for copies with this attribute. See CUmemcpyFlags + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.ownership' in found_struct}} + ownership : CUgraphChildGraphNodeOwnership + The ownership relationship of the child graph node. {{endif}} Methods @@ -4793,34 +4792,23 @@ cdef class CUmemcpyAttributes_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUmemcpyAttributes_st _pvt_val - cdef cydriver.CUmemcpyAttributes_st* _pvt_ptr - {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} - cdef CUmemLocation _srcLocHint - {{endif}} - {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} - cdef CUmemLocation _dstLocHint + cdef cydriver.CUDA_CHILD_GRAPH_NODE_PARAMS_st _pvt_val + cdef cydriver.CUDA_CHILD_GRAPH_NODE_PARAMS_st* _pvt_ptr + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} + cdef CUgraph _graph {{endif}} {{endif}} -{{if 'CUoffset3D_st' in found_struct}} +{{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st' in found_struct}} -cdef class CUoffset3D_st: +cdef class CUDA_EVENT_RECORD_NODE_PARAMS_st: """ - Struct representing offset into a CUarray in elements + Event record node parameters Attributes ---------- - {{if 'CUoffset3D_st.x' in found_struct}} - x : size_t - - {{endif}} - {{if 'CUoffset3D_st.y' in found_struct}} - y : size_t - - {{endif}} - {{if 'CUoffset3D_st.z' in found_struct}} - z : size_t - + {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} + event : CUevent + The event to record when the node executes {{endif}} Methods @@ -4828,28 +4816,23 @@ cdef class CUoffset3D_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUoffset3D_st _pvt_val - cdef cydriver.CUoffset3D_st* _pvt_ptr + cdef cydriver.CUDA_EVENT_RECORD_NODE_PARAMS_st _pvt_val + cdef cydriver.CUDA_EVENT_RECORD_NODE_PARAMS_st* _pvt_ptr + {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} + cdef CUevent _event + {{endif}} {{endif}} -{{if 'CUextent3D_st' in found_struct}} +{{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st' in found_struct}} -cdef class CUextent3D_st: +cdef class CUDA_EVENT_WAIT_NODE_PARAMS_st: """ - Struct representing width/height/depth of a CUarray in elements + Event wait node parameters Attributes ---------- - {{if 'CUextent3D_st.width' in found_struct}} - width : size_t - - {{endif}} - {{if 'CUextent3D_st.height' in found_struct}} - height : size_t - - {{endif}} - {{if 'CUextent3D_st.depth' in found_struct}} - depth : size_t - + {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} + event : CUevent + The event to wait on from the node {{endif}} Methods @@ -4857,30 +4840,87 @@ cdef class CUextent3D_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUextent3D_st _pvt_val - cdef cydriver.CUextent3D_st* _pvt_ptr + cdef cydriver.CUDA_EVENT_WAIT_NODE_PARAMS_st _pvt_val + cdef cydriver.CUDA_EVENT_WAIT_NODE_PARAMS_st* _pvt_ptr + {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} + cdef CUevent _event + {{endif}} {{endif}} -{{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} +{{if 'CUgraphNodeParams_st' in found_struct}} -cdef class anon_struct23: +cdef class CUgraphNodeParams_st: """ + Graph node parameters. See cuGraphAddNode. + Attributes ---------- - {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} - ptr : CUdeviceptr - + {{if 'CUgraphNodeParams_st.type' in found_struct}} + type : CUgraphNodeType + Type of the node {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.rowLength' in found_struct}} - rowLength : size_t - + {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} + reserved0 : List[int] + Reserved. Must be zero. {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.layerHeight' in found_struct}} - layerHeight : size_t - + {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} + reserved1 : List[long long] + Padding. Unused bytes must be zero. + {{endif}} + {{if 'CUgraphNodeParams_st.kernel' in found_struct}} + kernel : CUDA_KERNEL_NODE_PARAMS_v3 + Kernel node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} + memcpy : CUDA_MEMCPY_NODE_PARAMS + Memcpy node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memset' in found_struct}} + memset : CUDA_MEMSET_NODE_PARAMS_v2 + Memset node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.host' in found_struct}} + host : CUDA_HOST_NODE_PARAMS_v2 + Host node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.graph' in found_struct}} + graph : CUDA_CHILD_GRAPH_NODE_PARAMS + Child graph node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} + eventWait : CUDA_EVENT_WAIT_NODE_PARAMS + Event wait node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} + eventRecord : CUDA_EVENT_RECORD_NODE_PARAMS + Event record node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} + extSemSignal : CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 + External semaphore signal node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} + extSemWait : CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 + External semaphore wait node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.alloc' in found_struct}} + alloc : CUDA_MEM_ALLOC_NODE_PARAMS_v2 + Memory allocation node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.free' in found_struct}} + free : CUDA_MEM_FREE_NODE_PARAMS + Memory free node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memOp' in found_struct}} + memOp : CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 + MemOp node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + conditional : CUDA_CONDITIONAL_NODE_PARAMS + Conditional node parameters. {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} - locHint : CUmemLocation - + {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} + reserved2 : long long + Reserved bytes. Must be zero. {{endif}} Methods @@ -4888,27 +4928,68 @@ cdef class anon_struct23: getPtr() Get memory address of class instance """ - cdef cydriver.CUmemcpy3DOperand_st* _pvt_ptr - {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} - cdef CUdeviceptr _ptr + cdef cydriver.CUgraphNodeParams_st* _val_ptr + cdef cydriver.CUgraphNodeParams_st* _pvt_ptr + {{if 'CUgraphNodeParams_st.kernel' in found_struct}} + cdef CUDA_KERNEL_NODE_PARAMS_v3 _kernel {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} - cdef CUmemLocation _locHint + {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} + cdef CUDA_MEMCPY_NODE_PARAMS _memcpy + {{endif}} + {{if 'CUgraphNodeParams_st.memset' in found_struct}} + cdef CUDA_MEMSET_NODE_PARAMS_v2 _memset + {{endif}} + {{if 'CUgraphNodeParams_st.host' in found_struct}} + cdef CUDA_HOST_NODE_PARAMS_v2 _host + {{endif}} + {{if 'CUgraphNodeParams_st.graph' in found_struct}} + cdef CUDA_CHILD_GRAPH_NODE_PARAMS _graph + {{endif}} + {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} + cdef CUDA_EVENT_WAIT_NODE_PARAMS _eventWait + {{endif}} + {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} + cdef CUDA_EVENT_RECORD_NODE_PARAMS _eventRecord + {{endif}} + {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} + cdef CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 _extSemSignal + {{endif}} + {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} + cdef CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 _extSemWait + {{endif}} + {{if 'CUgraphNodeParams_st.alloc' in found_struct}} + cdef CUDA_MEM_ALLOC_NODE_PARAMS_v2 _alloc + {{endif}} + {{if 'CUgraphNodeParams_st.free' in found_struct}} + cdef CUDA_MEM_FREE_NODE_PARAMS _free + {{endif}} + {{if 'CUgraphNodeParams_st.memOp' in found_struct}} + cdef CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 _memOp + {{endif}} + {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + cdef CUDA_CONDITIONAL_NODE_PARAMS _conditional {{endif}} {{endif}} -{{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} +{{if 'CUcheckpointLockArgs_st' in found_struct}} -cdef class anon_struct24: +cdef class CUcheckpointLockArgs_st: """ + CUDA checkpoint optional lock arguments + Attributes ---------- - {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} - array : CUarray - + {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} + timeoutMs : unsigned int + Timeout in milliseconds to attempt to lock the process, 0 indicates + no timeout {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} - offset : CUoffset3D - + {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} + reserved0 : unsigned int + Reserved for future use, must be zero + {{endif}} + {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} + reserved1 : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -4916,27 +4997,20 @@ cdef class anon_struct24: getPtr() Get memory address of class instance """ - cdef cydriver.CUmemcpy3DOperand_st* _pvt_ptr - {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} - cdef CUarray _array - {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} - cdef CUoffset3D _offset - {{endif}} + cdef cydriver.CUcheckpointLockArgs_st _pvt_val + cdef cydriver.CUcheckpointLockArgs_st* _pvt_ptr {{endif}} -{{if 'CUmemcpy3DOperand_st.op' in found_struct}} +{{if 'CUcheckpointCheckpointArgs_st' in found_struct}} -cdef class anon_union13: +cdef class CUcheckpointCheckpointArgs_st: """ + CUDA checkpoint optional checkpoint arguments + Attributes ---------- - {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} - ptr : anon_struct23 - - {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} - array : anon_struct24 - + {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -4944,29 +5018,20 @@ cdef class anon_union13: getPtr() Get memory address of class instance """ - cdef cydriver.CUmemcpy3DOperand_st* _pvt_ptr - {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} - cdef anon_struct23 _ptr - {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} - cdef anon_struct24 _array - {{endif}} + cdef cydriver.CUcheckpointCheckpointArgs_st _pvt_val + cdef cydriver.CUcheckpointCheckpointArgs_st* _pvt_ptr {{endif}} -{{if 'CUmemcpy3DOperand_st' in found_struct}} +{{if 'CUcheckpointRestoreArgs_st' in found_struct}} -cdef class CUmemcpy3DOperand_st: +cdef class CUcheckpointRestoreArgs_st: """ - Struct representing an operand for copy with cuMemcpy3DBatchAsync + CUDA checkpoint optional restore arguments Attributes ---------- - {{if 'CUmemcpy3DOperand_st.type' in found_struct}} - type : CUmemcpy3DOperandType - - {{endif}} - {{if 'CUmemcpy3DOperand_st.op' in found_struct}} - op : anon_union13 - + {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -4974,38 +5039,20 @@ cdef class CUmemcpy3DOperand_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUmemcpy3DOperand_st* _val_ptr - cdef cydriver.CUmemcpy3DOperand_st* _pvt_ptr - {{if 'CUmemcpy3DOperand_st.op' in found_struct}} - cdef anon_union13 _op - {{endif}} + cdef cydriver.CUcheckpointRestoreArgs_st _pvt_val + cdef cydriver.CUcheckpointRestoreArgs_st* _pvt_ptr {{endif}} -{{if 'CUDA_MEMCPY3D_BATCH_OP_st' in found_struct}} +{{if 'CUcheckpointUnlockArgs_st' in found_struct}} -cdef class CUDA_MEMCPY3D_BATCH_OP_st: +cdef class CUcheckpointUnlockArgs_st: """ + CUDA checkpoint optional unlock arguments + Attributes ---------- - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} - src : CUmemcpy3DOperand - Source memcpy operand. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} - dst : CUmemcpy3DOperand - Destination memcpy operand. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} - extent : CUextent3D - Extents of the memcpy between src and dst. The width, height and - depth components must not be 0. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} - srcAccessOrder : CUmemcpySrcAccessOrder - Source access ordering to be observed for copy from src to dst. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} - flags : unsigned int - Additional flags for copies with this attribute. See CUmemcpyFlags + {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -5013,17 +5060,8 @@ cdef class CUDA_MEMCPY3D_BATCH_OP_st: getPtr() Get memory address of class instance """ - cdef cydriver.CUDA_MEMCPY3D_BATCH_OP_st _pvt_val - cdef cydriver.CUDA_MEMCPY3D_BATCH_OP_st* _pvt_ptr - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} - cdef CUmemcpy3DOperand _src - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} - cdef CUmemcpy3DOperand _dst - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} - cdef CUextent3D _extent - {{endif}} + cdef cydriver.CUcheckpointUnlockArgs_st _pvt_val + cdef cydriver.CUcheckpointUnlockArgs_st* _pvt_ptr {{endif}} {{if 'CUmemDecompressParams_st' in found_struct}} @@ -5116,7 +5154,7 @@ cdef class CUdevResource_st: {{endif}} {{if 'CUdevResource_st.sm' in found_struct}} sm : CUdevSmResource - Resource corresponding to CU_DEV_RESOURCE_TYPE_SM ``. type. + Resource corresponding to CU_DEV_RESOURCE_TYPE_SM `typename`. {{endif}} {{if 'CUdevResource_st._oversize' in found_struct}} _oversize : bytes @@ -5622,11 +5660,12 @@ cdef class CUasyncNotificationInfo(CUasyncNotificationInfo_st): ---------- {{if 'CUasyncNotificationInfo_st.type' in found_struct}} type : CUasyncNotificationType - + The type of notification being sent {{endif}} {{if 'CUasyncNotificationInfo_st.info' in found_struct}} info : anon_union2 - + Information about the notification. `typename` must be checked in + order to interpret this field. {{endif}} Methods @@ -9732,101 +9771,21 @@ cdef class CUmemPoolProps(CUmemPoolProps_v1): Windows-specific LPSECURITYATTRIBUTES required when CU_MEM_HANDLE_TYPE_WIN32 is specified. This security attribute defines the scope of which exported allocations may be transferred - to other processes. In all other cases, this field is required to - be zero. - {{endif}} - {{if 'CUmemPoolProps_st.maxSize' in found_struct}} - maxSize : size_t - Maximum pool size. When set to 0, defaults to a system dependent - value. - {{endif}} - {{if 'CUmemPoolProps_st.usage' in found_struct}} - usage : unsigned short - Bitmask indicating intended usage for the pool. - {{endif}} - {{if 'CUmemPoolProps_st.reserved' in found_struct}} - reserved : bytes - reserved for future use, must be 0 - {{endif}} - - Methods - ------- - getPtr() - Get memory address of class instance - """ - pass -{{endif}} -{{if 'CUmemPoolPtrExportData_v1' in found_types}} - -cdef class CUmemPoolPtrExportData_v1(CUmemPoolPtrExportData_st): - """ - Opaque data for exporting a pool allocation - - Attributes - ---------- - {{if 'CUmemPoolPtrExportData_st.reserved' in found_struct}} - reserved : bytes - - {{endif}} - - Methods - ------- - getPtr() - Get memory address of class instance - """ - pass -{{endif}} -{{if 'CUmemPoolPtrExportData' in found_types}} - -cdef class CUmemPoolPtrExportData(CUmemPoolPtrExportData_v1): - """ - Opaque data for exporting a pool allocation - - Attributes - ---------- - {{if 'CUmemPoolPtrExportData_st.reserved' in found_struct}} - reserved : bytes - - {{endif}} - - Methods - ------- - getPtr() - Get memory address of class instance - """ - pass -{{endif}} -{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1' in found_types}} - -cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1(CUDA_MEM_ALLOC_NODE_PARAMS_v1_st): - """ - Memory allocation node parameters - - Attributes - ---------- - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} - poolProps : CUmemPoolProps - in: location where the allocation should reside (specified in - ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is - not supported. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} - accessDescs : CUmemAccessDesc - in: array of memory access descriptors. Used to describe peer GPU - access + to other processes. In all other cases, this field is required to + be zero. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} - accessDescCount : size_t - in: number of memory access descriptors. Must not exceed the number - of GPUs. + {{if 'CUmemPoolProps_st.maxSize' in found_struct}} + maxSize : size_t + Maximum pool size. When set to 0, defaults to a system dependent + value. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} - bytesize : size_t - in: size in bytes of the requested allocation + {{if 'CUmemPoolProps_st.usage' in found_struct}} + usage : unsigned short + Bitmask indicating intended usage for the pool. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} - dptr : CUdeviceptr - out: address of the allocation returned by CUDA + {{if 'CUmemPoolProps_st.reserved' in found_struct}} + reserved : bytes + reserved for future use, must be 0 {{endif}} Methods @@ -9836,37 +9795,17 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1(CUDA_MEM_ALLOC_NODE_PARAMS_v1_st): """ pass {{endif}} -{{if 'CUDA_MEM_ALLOC_NODE_PARAMS' in found_types}} +{{if 'CUmemPoolPtrExportData_v1' in found_types}} -cdef class CUDA_MEM_ALLOC_NODE_PARAMS(CUDA_MEM_ALLOC_NODE_PARAMS_v1): +cdef class CUmemPoolPtrExportData_v1(CUmemPoolPtrExportData_st): """ - Memory allocation node parameters + Opaque data for exporting a pool allocation Attributes ---------- - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} - poolProps : CUmemPoolProps - in: location where the allocation should reside (specified in - ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is - not supported. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} - accessDescs : CUmemAccessDesc - in: array of memory access descriptors. Used to describe peer GPU - access - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} - accessDescCount : size_t - in: number of memory access descriptors. Must not exceed the number - of GPUs. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} - bytesize : size_t - in: size in bytes of the requested allocation - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} - dptr : CUdeviceptr - out: address of the allocation returned by CUDA + {{if 'CUmemPoolPtrExportData_st.reserved' in found_struct}} + reserved : bytes + {{endif}} Methods @@ -9876,37 +9815,17 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS(CUDA_MEM_ALLOC_NODE_PARAMS_v1): """ pass {{endif}} -{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2' in found_types}} +{{if 'CUmemPoolPtrExportData' in found_types}} -cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2(CUDA_MEM_ALLOC_NODE_PARAMS_v2_st): +cdef class CUmemPoolPtrExportData(CUmemPoolPtrExportData_v1): """ - Memory allocation node parameters + Opaque data for exporting a pool allocation Attributes ---------- - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} - poolProps : CUmemPoolProps - in: location where the allocation should reside (specified in - ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is - not supported. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} - accessDescs : CUmemAccessDesc - in: array of memory access descriptors. Used to describe peer GPU - access - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} - accessDescCount : size_t - in: number of memory access descriptors. Must not exceed the number - of GPUs. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} - bytesize : size_t - in: size in bytes of the requested allocation - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} - dptr : CUdeviceptr - out: address of the allocation returned by CUDA + {{if 'CUmemPoolPtrExportData_st.reserved' in found_struct}} + reserved : bytes + {{endif}} Methods @@ -9916,17 +9835,33 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2(CUDA_MEM_ALLOC_NODE_PARAMS_v2_st): """ pass {{endif}} -{{if 'CUDA_MEM_FREE_NODE_PARAMS' in found_types}} +{{if 'CUmemcpyAttributes_v1' in found_types}} -cdef class CUDA_MEM_FREE_NODE_PARAMS(CUDA_MEM_FREE_NODE_PARAMS_st): +cdef class CUmemcpyAttributes_v1(CUmemcpyAttributes_st): """ - Memory free node parameters + Attributes specific to copies within a batch. For more details on + usage see cuMemcpyBatchAsync. Attributes ---------- - {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} - dptr : CUdeviceptr - in: the pointer to free + {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} + srcAccessOrder : CUmemcpySrcAccessOrder + Source access ordering to be observed for copies with this + attribute. + {{endif}} + {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} + srcLocHint : CUmemLocation + Hint location for the source operand. Ignored when the pointers are + not managed memory or memory allocated outside CUDA. + {{endif}} + {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} + dstLocHint : CUmemLocation + Hint location for the destination operand. Ignored when the + pointers are not managed memory or memory allocated outside CUDA. + {{endif}} + {{if 'CUmemcpyAttributes_st.flags' in found_struct}} + flags : unsigned int + Additional flags for copies with this attribute. See CUmemcpyFlags {{endif}} Methods @@ -9936,18 +9871,33 @@ cdef class CUDA_MEM_FREE_NODE_PARAMS(CUDA_MEM_FREE_NODE_PARAMS_st): """ pass {{endif}} -{{if 'CUDA_CHILD_GRAPH_NODE_PARAMS' in found_types}} +{{if 'CUmemcpyAttributes' in found_types}} -cdef class CUDA_CHILD_GRAPH_NODE_PARAMS(CUDA_CHILD_GRAPH_NODE_PARAMS_st): +cdef class CUmemcpyAttributes(CUmemcpyAttributes_v1): """ - Child graph node parameters + Attributes specific to copies within a batch. For more details on + usage see cuMemcpyBatchAsync. Attributes ---------- - {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} - graph : CUgraph - The child graph to clone into the node for node creation, or a - handle to the graph owned by the node for node query + {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} + srcAccessOrder : CUmemcpySrcAccessOrder + Source access ordering to be observed for copies with this + attribute. + {{endif}} + {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} + srcLocHint : CUmemLocation + Hint location for the source operand. Ignored when the pointers are + not managed memory or memory allocated outside CUDA. + {{endif}} + {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} + dstLocHint : CUmemLocation + Hint location for the destination operand. Ignored when the + pointers are not managed memory or memory allocated outside CUDA. + {{endif}} + {{if 'CUmemcpyAttributes_st.flags' in found_struct}} + flags : unsigned int + Additional flags for copies with this attribute. See CUmemcpyFlags {{endif}} Methods @@ -9957,17 +9907,25 @@ cdef class CUDA_CHILD_GRAPH_NODE_PARAMS(CUDA_CHILD_GRAPH_NODE_PARAMS_st): """ pass {{endif}} -{{if 'CUDA_EVENT_RECORD_NODE_PARAMS' in found_types}} +{{if 'CUoffset3D_v1' in found_types}} -cdef class CUDA_EVENT_RECORD_NODE_PARAMS(CUDA_EVENT_RECORD_NODE_PARAMS_st): +cdef class CUoffset3D_v1(CUoffset3D_st): """ - Event record node parameters + Struct representing offset into a CUarray in elements Attributes ---------- - {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} - event : CUevent - The event to record when the node executes + {{if 'CUoffset3D_st.x' in found_struct}} + x : size_t + + {{endif}} + {{if 'CUoffset3D_st.y' in found_struct}} + y : size_t + + {{endif}} + {{if 'CUoffset3D_st.z' in found_struct}} + z : size_t + {{endif}} Methods @@ -9977,17 +9935,25 @@ cdef class CUDA_EVENT_RECORD_NODE_PARAMS(CUDA_EVENT_RECORD_NODE_PARAMS_st): """ pass {{endif}} -{{if 'CUDA_EVENT_WAIT_NODE_PARAMS' in found_types}} +{{if 'CUoffset3D' in found_types}} -cdef class CUDA_EVENT_WAIT_NODE_PARAMS(CUDA_EVENT_WAIT_NODE_PARAMS_st): +cdef class CUoffset3D(CUoffset3D_v1): """ - Event wait node parameters + Struct representing offset into a CUarray in elements Attributes ---------- - {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} - event : CUevent - The event to wait on from the node + {{if 'CUoffset3D_st.x' in found_struct}} + x : size_t + + {{endif}} + {{if 'CUoffset3D_st.y' in found_struct}} + y : size_t + + {{endif}} + {{if 'CUoffset3D_st.z' in found_struct}} + z : size_t + {{endif}} Methods @@ -9997,81 +9963,25 @@ cdef class CUDA_EVENT_WAIT_NODE_PARAMS(CUDA_EVENT_WAIT_NODE_PARAMS_st): """ pass {{endif}} -{{if 'CUgraphNodeParams' in found_types}} +{{if 'CUextent3D_v1' in found_types}} -cdef class CUgraphNodeParams(CUgraphNodeParams_st): +cdef class CUextent3D_v1(CUextent3D_st): """ - Graph node parameters. See cuGraphAddNode. + Struct representing width/height/depth of a CUarray in elements Attributes ---------- - {{if 'CUgraphNodeParams_st.type' in found_struct}} - type : CUgraphNodeType - Type of the node - {{endif}} - {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} - reserved0 : List[int] - Reserved. Must be zero. - {{endif}} - {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} - reserved1 : List[long long] - Padding. Unused bytes must be zero. - {{endif}} - {{if 'CUgraphNodeParams_st.kernel' in found_struct}} - kernel : CUDA_KERNEL_NODE_PARAMS_v3 - Kernel node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} - memcpy : CUDA_MEMCPY_NODE_PARAMS - Memcpy node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memset' in found_struct}} - memset : CUDA_MEMSET_NODE_PARAMS_v2 - Memset node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.host' in found_struct}} - host : CUDA_HOST_NODE_PARAMS_v2 - Host node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.graph' in found_struct}} - graph : CUDA_CHILD_GRAPH_NODE_PARAMS - Child graph node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} - eventWait : CUDA_EVENT_WAIT_NODE_PARAMS - Event wait node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} - eventRecord : CUDA_EVENT_RECORD_NODE_PARAMS - Event record node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} - extSemSignal : CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 - External semaphore signal node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} - extSemWait : CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 - External semaphore wait node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.alloc' in found_struct}} - alloc : CUDA_MEM_ALLOC_NODE_PARAMS_v2 - Memory allocation node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.free' in found_struct}} - free : CUDA_MEM_FREE_NODE_PARAMS - Memory free node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memOp' in found_struct}} - memOp : CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 - MemOp node parameters. + {{if 'CUextent3D_st.width' in found_struct}} + width : size_t + {{endif}} - {{if 'CUgraphNodeParams_st.conditional' in found_struct}} - conditional : CUDA_CONDITIONAL_NODE_PARAMS - Conditional node parameters. + {{if 'CUextent3D_st.height' in found_struct}} + height : size_t + {{endif}} - {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} - reserved2 : long long - Reserved bytes. Must be zero. + {{if 'CUextent3D_st.depth' in found_struct}} + depth : size_t + {{endif}} Methods @@ -10081,26 +9991,25 @@ cdef class CUgraphNodeParams(CUgraphNodeParams_st): """ pass {{endif}} -{{if 'CUcheckpointLockArgs' in found_types}} +{{if 'CUextent3D' in found_types}} -cdef class CUcheckpointLockArgs(CUcheckpointLockArgs_st): +cdef class CUextent3D(CUextent3D_v1): """ - CUDA checkpoint optional lock arguments + Struct representing width/height/depth of a CUarray in elements Attributes ---------- - {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} - timeoutMs : unsigned int - Timeout in milliseconds to attempt to lock the process, 0 indicates - no timeout + {{if 'CUextent3D_st.width' in found_struct}} + width : size_t + {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} - reserved0 : unsigned int - Reserved for future use, must be zero + {{if 'CUextent3D_st.height' in found_struct}} + height : size_t + {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} - reserved1 : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUextent3D_st.depth' in found_struct}} + depth : size_t + {{endif}} Methods @@ -10110,17 +10019,21 @@ cdef class CUcheckpointLockArgs(CUcheckpointLockArgs_st): """ pass {{endif}} -{{if 'CUcheckpointCheckpointArgs' in found_types}} +{{if 'CUmemcpy3DOperand_v1' in found_types}} -cdef class CUcheckpointCheckpointArgs(CUcheckpointCheckpointArgs_st): +cdef class CUmemcpy3DOperand_v1(CUmemcpy3DOperand_st): """ - CUDA checkpoint optional checkpoint arguments + Struct representing an operand for copy with cuMemcpy3DBatchAsync Attributes ---------- - {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUmemcpy3DOperand_st.type' in found_struct}} + type : CUmemcpy3DOperandType + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + op : anon_union12 + {{endif}} Methods @@ -10130,17 +10043,21 @@ cdef class CUcheckpointCheckpointArgs(CUcheckpointCheckpointArgs_st): """ pass {{endif}} -{{if 'CUcheckpointRestoreArgs' in found_types}} +{{if 'CUmemcpy3DOperand' in found_types}} -cdef class CUcheckpointRestoreArgs(CUcheckpointRestoreArgs_st): +cdef class CUmemcpy3DOperand(CUmemcpy3DOperand_v1): """ - CUDA checkpoint optional restore arguments + Struct representing an operand for copy with cuMemcpy3DBatchAsync Attributes ---------- - {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUmemcpy3DOperand_st.type' in found_struct}} + type : CUmemcpy3DOperandType + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + op : anon_union12 + {{endif}} Methods @@ -10150,17 +10067,32 @@ cdef class CUcheckpointRestoreArgs(CUcheckpointRestoreArgs_st): """ pass {{endif}} -{{if 'CUcheckpointUnlockArgs' in found_types}} +{{if 'CUDA_MEMCPY3D_BATCH_OP_v1' in found_types}} -cdef class CUcheckpointUnlockArgs(CUcheckpointUnlockArgs_st): +cdef class CUDA_MEMCPY3D_BATCH_OP_v1(CUDA_MEMCPY3D_BATCH_OP_st): """ - CUDA checkpoint optional unlock arguments - Attributes ---------- - {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} + src : CUmemcpy3DOperand + Source memcpy operand. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} + dst : CUmemcpy3DOperand + Destination memcpy operand. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} + extent : CUextent3D + Extents of the memcpy between src and dst. The width, height and + depth components must not be 0. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} + srcAccessOrder : CUmemcpySrcAccessOrder + Source access ordering to be observed for copy from src to dst. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} + flags : unsigned int + Additional flags for copies with this attribute. See CUmemcpyFlags {{endif}} Methods @@ -10170,31 +10102,30 @@ cdef class CUcheckpointUnlockArgs(CUcheckpointUnlockArgs_st): """ pass {{endif}} -{{if 'CUmemcpyAttributes_v1' in found_types}} +{{if 'CUDA_MEMCPY3D_BATCH_OP' in found_types}} -cdef class CUmemcpyAttributes_v1(CUmemcpyAttributes_st): +cdef class CUDA_MEMCPY3D_BATCH_OP(CUDA_MEMCPY3D_BATCH_OP_v1): """ - Attributes specific to copies within a batch. For more details on - usage see cuMemcpyBatchAsync. - Attributes ---------- - {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} - srcAccessOrder : CUmemcpySrcAccessOrder - Source access ordering to be observed for copies with this - attribute. + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} + src : CUmemcpy3DOperand + Source memcpy operand. {{endif}} - {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} - srcLocHint : CUmemLocation - Hint location for the source operand. Ignored when the pointers are - not managed memory or memory allocated outside CUDA. + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} + dst : CUmemcpy3DOperand + Destination memcpy operand. {{endif}} - {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} - dstLocHint : CUmemLocation - Hint location for the destination operand. Ignored when the - pointers are not managed memory or memory allocated outside CUDA. + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} + extent : CUextent3D + Extents of the memcpy between src and dst. The width, height and + depth components must not be 0. {{endif}} - {{if 'CUmemcpyAttributes_st.flags' in found_struct}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} + srcAccessOrder : CUmemcpySrcAccessOrder + Source access ordering to be observed for copy from src to dst. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} flags : unsigned int Additional flags for copies with this attribute. See CUmemcpyFlags {{endif}} @@ -10206,33 +10137,137 @@ cdef class CUmemcpyAttributes_v1(CUmemcpyAttributes_st): """ pass {{endif}} -{{if 'CUmemcpyAttributes' in found_types}} +{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1' in found_types}} -cdef class CUmemcpyAttributes(CUmemcpyAttributes_v1): +cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1(CUDA_MEM_ALLOC_NODE_PARAMS_v1_st): """ - Attributes specific to copies within a batch. For more details on - usage see cuMemcpyBatchAsync. + Memory allocation node parameters Attributes ---------- - {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} - srcAccessOrder : CUmemcpySrcAccessOrder - Source access ordering to be observed for copies with this - attribute. + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} + poolProps : CUmemPoolProps + in: location where the allocation should reside (specified in + ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is + not supported. {{endif}} - {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} - srcLocHint : CUmemLocation - Hint location for the source operand. Ignored when the pointers are - not managed memory or memory allocated outside CUDA. + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + accessDescs : CUmemAccessDesc + in: array of memory access descriptors. Used to describe peer GPU + access {{endif}} - {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} - dstLocHint : CUmemLocation - Hint location for the destination operand. Ignored when the - pointers are not managed memory or memory allocated outside CUDA. + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} + accessDescCount : size_t + in: number of memory access descriptors. Must not exceed the number + of GPUs. {{endif}} - {{if 'CUmemcpyAttributes_st.flags' in found_struct}} - flags : unsigned int - Additional flags for copies with this attribute. See CUmemcpyFlags + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} + bytesize : size_t + in: size in bytes of the requested allocation + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + dptr : CUdeviceptr + out: address of the allocation returned by CUDA + {{endif}} + + Methods + ------- + getPtr() + Get memory address of class instance + """ + pass +{{endif}} +{{if 'CUDA_MEM_ALLOC_NODE_PARAMS' in found_types}} + +cdef class CUDA_MEM_ALLOC_NODE_PARAMS(CUDA_MEM_ALLOC_NODE_PARAMS_v1): + """ + Memory allocation node parameters + + Attributes + ---------- + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} + poolProps : CUmemPoolProps + in: location where the allocation should reside (specified in + ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is + not supported. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + accessDescs : CUmemAccessDesc + in: array of memory access descriptors. Used to describe peer GPU + access + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} + accessDescCount : size_t + in: number of memory access descriptors. Must not exceed the number + of GPUs. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} + bytesize : size_t + in: size in bytes of the requested allocation + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + dptr : CUdeviceptr + out: address of the allocation returned by CUDA + {{endif}} + + Methods + ------- + getPtr() + Get memory address of class instance + """ + pass +{{endif}} +{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2' in found_types}} + +cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2(CUDA_MEM_ALLOC_NODE_PARAMS_v2_st): + """ + Memory allocation node parameters + + Attributes + ---------- + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} + poolProps : CUmemPoolProps + in: location where the allocation should reside (specified in + ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is + not supported. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} + accessDescs : CUmemAccessDesc + in: array of memory access descriptors. Used to describe peer GPU + access + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} + accessDescCount : size_t + in: number of memory access descriptors. Must not exceed the number + of GPUs. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} + bytesize : size_t + in: size in bytes of the requested allocation + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + dptr : CUdeviceptr + out: address of the allocation returned by CUDA + {{endif}} + + Methods + ------- + getPtr() + Get memory address of class instance + """ + pass +{{endif}} +{{if 'CUDA_MEM_FREE_NODE_PARAMS' in found_types}} + +cdef class CUDA_MEM_FREE_NODE_PARAMS(CUDA_MEM_FREE_NODE_PARAMS_st): + """ + Memory free node parameters + + Attributes + ---------- + {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} + dptr : CUdeviceptr + in: the pointer to free {{endif}} Methods @@ -10242,25 +10277,25 @@ cdef class CUmemcpyAttributes(CUmemcpyAttributes_v1): """ pass {{endif}} -{{if 'CUoffset3D_v1' in found_types}} +{{if 'CUDA_CHILD_GRAPH_NODE_PARAMS' in found_types}} -cdef class CUoffset3D_v1(CUoffset3D_st): +cdef class CUDA_CHILD_GRAPH_NODE_PARAMS(CUDA_CHILD_GRAPH_NODE_PARAMS_st): """ - Struct representing offset into a CUarray in elements + Child graph node parameters Attributes ---------- - {{if 'CUoffset3D_st.x' in found_struct}} - x : size_t - - {{endif}} - {{if 'CUoffset3D_st.y' in found_struct}} - y : size_t - + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} + graph : CUgraph + The child graph to clone into the node for node creation, or a + handle to the graph owned by the node for node query. The graph + must not contain conditional nodes. Graphs containing memory + allocation or memory free nodes must set the ownership to be moved + to the parent. {{endif}} - {{if 'CUoffset3D_st.z' in found_struct}} - z : size_t - + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.ownership' in found_struct}} + ownership : CUgraphChildGraphNodeOwnership + The ownership relationship of the child graph node. {{endif}} Methods @@ -10270,25 +10305,17 @@ cdef class CUoffset3D_v1(CUoffset3D_st): """ pass {{endif}} -{{if 'CUoffset3D' in found_types}} +{{if 'CUDA_EVENT_RECORD_NODE_PARAMS' in found_types}} -cdef class CUoffset3D(CUoffset3D_v1): +cdef class CUDA_EVENT_RECORD_NODE_PARAMS(CUDA_EVENT_RECORD_NODE_PARAMS_st): """ - Struct representing offset into a CUarray in elements + Event record node parameters Attributes ---------- - {{if 'CUoffset3D_st.x' in found_struct}} - x : size_t - - {{endif}} - {{if 'CUoffset3D_st.y' in found_struct}} - y : size_t - - {{endif}} - {{if 'CUoffset3D_st.z' in found_struct}} - z : size_t - + {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} + event : CUevent + The event to record when the node executes {{endif}} Methods @@ -10298,25 +10325,17 @@ cdef class CUoffset3D(CUoffset3D_v1): """ pass {{endif}} -{{if 'CUextent3D_v1' in found_types}} +{{if 'CUDA_EVENT_WAIT_NODE_PARAMS' in found_types}} -cdef class CUextent3D_v1(CUextent3D_st): +cdef class CUDA_EVENT_WAIT_NODE_PARAMS(CUDA_EVENT_WAIT_NODE_PARAMS_st): """ - Struct representing width/height/depth of a CUarray in elements + Event wait node parameters Attributes ---------- - {{if 'CUextent3D_st.width' in found_struct}} - width : size_t - - {{endif}} - {{if 'CUextent3D_st.height' in found_struct}} - height : size_t - - {{endif}} - {{if 'CUextent3D_st.depth' in found_struct}} - depth : size_t - + {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} + event : CUevent + The event to wait on from the node {{endif}} Methods @@ -10326,25 +10345,81 @@ cdef class CUextent3D_v1(CUextent3D_st): """ pass {{endif}} -{{if 'CUextent3D' in found_types}} +{{if 'CUgraphNodeParams' in found_types}} -cdef class CUextent3D(CUextent3D_v1): +cdef class CUgraphNodeParams(CUgraphNodeParams_st): """ - Struct representing width/height/depth of a CUarray in elements + Graph node parameters. See cuGraphAddNode. Attributes ---------- - {{if 'CUextent3D_st.width' in found_struct}} - width : size_t - + {{if 'CUgraphNodeParams_st.type' in found_struct}} + type : CUgraphNodeType + Type of the node {{endif}} - {{if 'CUextent3D_st.height' in found_struct}} - height : size_t - + {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} + reserved0 : List[int] + Reserved. Must be zero. {{endif}} - {{if 'CUextent3D_st.depth' in found_struct}} - depth : size_t - + {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} + reserved1 : List[long long] + Padding. Unused bytes must be zero. + {{endif}} + {{if 'CUgraphNodeParams_st.kernel' in found_struct}} + kernel : CUDA_KERNEL_NODE_PARAMS_v3 + Kernel node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} + memcpy : CUDA_MEMCPY_NODE_PARAMS + Memcpy node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memset' in found_struct}} + memset : CUDA_MEMSET_NODE_PARAMS_v2 + Memset node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.host' in found_struct}} + host : CUDA_HOST_NODE_PARAMS_v2 + Host node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.graph' in found_struct}} + graph : CUDA_CHILD_GRAPH_NODE_PARAMS + Child graph node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} + eventWait : CUDA_EVENT_WAIT_NODE_PARAMS + Event wait node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} + eventRecord : CUDA_EVENT_RECORD_NODE_PARAMS + Event record node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} + extSemSignal : CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 + External semaphore signal node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} + extSemWait : CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 + External semaphore wait node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.alloc' in found_struct}} + alloc : CUDA_MEM_ALLOC_NODE_PARAMS_v2 + Memory allocation node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.free' in found_struct}} + free : CUDA_MEM_FREE_NODE_PARAMS + Memory free node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memOp' in found_struct}} + memOp : CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 + MemOp node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + conditional : CUDA_CONDITIONAL_NODE_PARAMS + Conditional node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} + reserved2 : long long + Reserved bytes. Must be zero. {{endif}} Methods @@ -10354,21 +10429,26 @@ cdef class CUextent3D(CUextent3D_v1): """ pass {{endif}} -{{if 'CUmemcpy3DOperand_v1' in found_types}} +{{if 'CUcheckpointLockArgs' in found_types}} -cdef class CUmemcpy3DOperand_v1(CUmemcpy3DOperand_st): +cdef class CUcheckpointLockArgs(CUcheckpointLockArgs_st): """ - Struct representing an operand for copy with cuMemcpy3DBatchAsync + CUDA checkpoint optional lock arguments Attributes ---------- - {{if 'CUmemcpy3DOperand_st.type' in found_struct}} - type : CUmemcpy3DOperandType - + {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} + timeoutMs : unsigned int + Timeout in milliseconds to attempt to lock the process, 0 indicates + no timeout {{endif}} - {{if 'CUmemcpy3DOperand_st.op' in found_struct}} - op : anon_union13 - + {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} + reserved0 : unsigned int + Reserved for future use, must be zero + {{endif}} + {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} + reserved1 : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -10378,21 +10458,17 @@ cdef class CUmemcpy3DOperand_v1(CUmemcpy3DOperand_st): """ pass {{endif}} -{{if 'CUmemcpy3DOperand' in found_types}} +{{if 'CUcheckpointCheckpointArgs' in found_types}} -cdef class CUmemcpy3DOperand(CUmemcpy3DOperand_v1): +cdef class CUcheckpointCheckpointArgs(CUcheckpointCheckpointArgs_st): """ - Struct representing an operand for copy with cuMemcpy3DBatchAsync + CUDA checkpoint optional checkpoint arguments Attributes ---------- - {{if 'CUmemcpy3DOperand_st.type' in found_struct}} - type : CUmemcpy3DOperandType - - {{endif}} - {{if 'CUmemcpy3DOperand_st.op' in found_struct}} - op : anon_union13 - + {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -10402,32 +10478,17 @@ cdef class CUmemcpy3DOperand(CUmemcpy3DOperand_v1): """ pass {{endif}} -{{if 'CUDA_MEMCPY3D_BATCH_OP_v1' in found_types}} +{{if 'CUcheckpointRestoreArgs' in found_types}} -cdef class CUDA_MEMCPY3D_BATCH_OP_v1(CUDA_MEMCPY3D_BATCH_OP_st): +cdef class CUcheckpointRestoreArgs(CUcheckpointRestoreArgs_st): """ + CUDA checkpoint optional restore arguments + Attributes ---------- - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} - src : CUmemcpy3DOperand - Source memcpy operand. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} - dst : CUmemcpy3DOperand - Destination memcpy operand. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} - extent : CUextent3D - Extents of the memcpy between src and dst. The width, height and - depth components must not be 0. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} - srcAccessOrder : CUmemcpySrcAccessOrder - Source access ordering to be observed for copy from src to dst. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} - flags : unsigned int - Additional flags for copies with this attribute. See CUmemcpyFlags + {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -10437,32 +10498,17 @@ cdef class CUDA_MEMCPY3D_BATCH_OP_v1(CUDA_MEMCPY3D_BATCH_OP_st): """ pass {{endif}} -{{if 'CUDA_MEMCPY3D_BATCH_OP' in found_types}} +{{if 'CUcheckpointUnlockArgs' in found_types}} -cdef class CUDA_MEMCPY3D_BATCH_OP(CUDA_MEMCPY3D_BATCH_OP_v1): +cdef class CUcheckpointUnlockArgs(CUcheckpointUnlockArgs_st): """ + CUDA checkpoint optional unlock arguments + Attributes ---------- - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} - src : CUmemcpy3DOperand - Source memcpy operand. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} - dst : CUmemcpy3DOperand - Destination memcpy operand. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} - extent : CUextent3D - Extents of the memcpy between src and dst. The width, height and - depth components must not be 0. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} - srcAccessOrder : CUmemcpySrcAccessOrder - Source access ordering to be observed for copy from src to dst. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} - flags : unsigned int - Additional flags for copies with this attribute. See CUmemcpyFlags + {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -10561,7 +10607,7 @@ cdef class CUdevResource_v1(CUdevResource_st): {{endif}} {{if 'CUdevResource_st.sm' in found_struct}} sm : CUdevSmResource - Resource corresponding to CU_DEV_RESOURCE_TYPE_SM ``. type. + Resource corresponding to CU_DEV_RESOURCE_TYPE_SM `typename`. {{endif}} {{if 'CUdevResource_st._oversize' in found_struct}} _oversize : bytes @@ -10591,7 +10637,7 @@ cdef class CUdevResource(CUdevResource_v1): {{endif}} {{if 'CUdevResource_st.sm' in found_struct}} sm : CUdevSmResource - Resource corresponding to CU_DEV_RESOURCE_TYPE_SM ``. type. + Resource corresponding to CU_DEV_RESOURCE_TYPE_SM `typename`. {{endif}} {{if 'CUdevResource_st._oversize' in found_struct}} _oversize : bytes @@ -10834,6 +10880,21 @@ cdef class CUmemGenericAllocationHandle_v1: cdef cydriver.CUmemGenericAllocationHandle_v1* _pvt_ptr {{endif}} +{{if 'CUlogIterator' in found_types}} + +cdef class CUlogIterator: + """ + + Methods + ------- + getPtr() + Get memory address of class instance + + """ + cdef cydriver.CUlogIterator _pvt_val + cdef cydriver.CUlogIterator* _pvt_ptr +{{endif}} + {{if True}} cdef class GLenum: diff --git a/cuda_bindings/cuda/bindings/driver.pyx.in b/cuda_bindings/cuda/bindings/driver.pyx.in index 248147990..b8771dd30 100644 --- a/cuda_bindings/cuda/bindings/driver.pyx.in +++ b/cuda_bindings/cuda/bindings/driver.pyx.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. from typing import List, Tuple, Any, Optional from enum import IntEnum import cython @@ -69,6 +69,8 @@ CU_STREAM_PER_THREAD = cydriver.CU_STREAM_PER_THREAD CU_COMPUTE_ACCELERATED_TARGET_BASE = cydriver.CU_COMPUTE_ACCELERATED_TARGET_BASE +CU_COMPUTE_FAMILY_TARGET_BASE = cydriver.CU_COMPUTE_FAMILY_TARGET_BASE + #: Conditional node handle flags Default value is applied when graph is #: launched. CU_GRAPH_COND_ASSIGN_DEFAULT = cydriver.CU_GRAPH_COND_ASSIGN_DEFAULT @@ -295,6 +297,9 @@ CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION = cydriver.CU_TRSF_DISABLE_TRILINEAR_OPTI #: :py:obj:`~.cuTexObjectCreate()` CU_TRSF_SEAMLESS_CUBEMAP = cydriver.CU_TRSF_SEAMLESS_CUBEMAP +#: Launch with the required block dimension. +CU_LAUNCH_KERNEL_REQUIRED_BLOCK_DIM = cydriver.CU_LAUNCH_KERNEL_REQUIRED_BLOCK_DIM + #: C++ compile time constant for CU_LAUNCH_PARAM_END CU_LAUNCH_PARAM_END_AS_INT = cydriver.CU_LAUNCH_PARAM_END_AS_INT @@ -694,7 +699,7 @@ _dict_CUstreamBatchMemOpType = dict(((int(v), v) for k, v in CUstreamBatchMemOpT class CUstreamMemoryBarrier_flags(IntEnum): """ - Flags for :py:obj:`~.cuStreamMemoryBarrier` + Flags for :py:obj:`~.CUstreamBatchMemOpParams`::memoryBarrier """ {{if 'CU_STREAM_MEMORY_BARRIER_TYPE_SYS' in found_values}} @@ -749,6 +754,8 @@ class CUasyncNotificationType(IntEnum): Types of async notification that can be sent """ {{if 'CU_ASYNC_NOTIFICATION_TYPE_OVER_BUDGET' in found_values}} + + #: Sent when the process has exceeded its device memory budget CU_ASYNC_NOTIFICATION_TYPE_OVER_BUDGET = cydriver.CUasyncNotificationType_enum.CU_ASYNC_NOTIFICATION_TYPE_OVER_BUDGET{{endif}} _dict_CUasyncNotificationType = dict(((int(v), v) for k, v in CUasyncNotificationType.__members__.items())) @@ -1396,8 +1403,7 @@ class CUdevice_attribute(IntEnum): {{if 'CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED' in found_values}} #: Link between the device and the host supports native atomic - #: operations (this is a placeholder attribute, and is not supported on - #: any current hardware) + #: operations CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED{{endif}} {{if 'CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO' in found_values}} @@ -1649,6 +1655,10 @@ class CUdevice_attribute(IntEnum): #: The returned valued is the maximum length in bytes of a single #: decompress operation that is allowed. CU_DEVICE_ATTRIBUTE_MEM_DECOMPRESS_MAXIMUM_LENGTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MEM_DECOMPRESS_MAXIMUM_LENGTH{{endif}} + {{if 'CU_DEVICE_ATTRIBUTE_VULKAN_CIG_SUPPORTED' in found_values}} + + #: Device supports CIG with Vulkan. + CU_DEVICE_ATTRIBUTE_VULKAN_CIG_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_VULKAN_CIG_SUPPORTED{{endif}} {{if 'CU_DEVICE_ATTRIBUTE_GPU_PCI_DEVICE_ID' in found_values}} #: The combined 16-bit PCI device ID and 16-bit PCI vendor ID. @@ -1658,6 +1668,17 @@ class CUdevice_attribute(IntEnum): #: The combined 16-bit PCI subsystem ID and 16-bit PCI subsystem vendor #: ID. CU_DEVICE_ATTRIBUTE_GPU_PCI_SUBSYSTEM_ID = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_PCI_SUBSYSTEM_ID{{endif}} + {{if 'CU_DEVICE_ATTRIBUTE_HOST_NUMA_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED' in found_values}} + + #: Device supports HOST_NUMA location with the virtual memory + #: management APIs like :py:obj:`~.cuMemCreate`, :py:obj:`~.cuMemMap` + #: and related APIs + CU_DEVICE_ATTRIBUTE_HOST_NUMA_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HOST_NUMA_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED{{endif}} + {{if 'CU_DEVICE_ATTRIBUTE_HOST_NUMA_MEMORY_POOLS_SUPPORTED' in found_values}} + + #: Device supports HOST_NUMA location with the + #: :py:obj:`~.cuMemAllocAsync` and :py:obj:`~.cuMemPool` family of APIs + CU_DEVICE_ATTRIBUTE_HOST_NUMA_MEMORY_POOLS_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HOST_NUMA_MEMORY_POOLS_SUPPORTED{{endif}} {{if 'CU_DEVICE_ATTRIBUTE_HOST_NUMA_MULTINODE_IPC_SUPPORTED' in found_values}} #: Device supports HOST_NUMA location IPC between nodes in a multi-node @@ -2465,11 +2486,19 @@ class CUjit_target(IntEnum): #: Compute device class 10.1. CU_TARGET_COMPUTE_101 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_101{{endif}} + {{if 'CU_TARGET_COMPUTE_103' in found_values}} + + #: Compute device class 10.3. + CU_TARGET_COMPUTE_103 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_103{{endif}} {{if 'CU_TARGET_COMPUTE_120' in found_values}} - #: Compute device class 12.0. Compute device class 9.0. with - #: accelerated features. + #: Compute device class 12.0. CU_TARGET_COMPUTE_120 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_120{{endif}} + {{if 'CU_TARGET_COMPUTE_121' in found_values}} + + #: Compute device class 12.1. Compute device class 9.0. with + #: accelerated features. + CU_TARGET_COMPUTE_121 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_121{{endif}} {{if 'CU_TARGET_COMPUTE_90A' in found_values}} #: Compute device class 10.0. with accelerated features. @@ -2480,10 +2509,38 @@ class CUjit_target(IntEnum): CU_TARGET_COMPUTE_100A = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_100A{{endif}} {{if 'CU_TARGET_COMPUTE_101A' in found_values}} - #: Compute device class 12.0. with accelerated features. + #: Compute device class 10.3. with accelerated features. CU_TARGET_COMPUTE_101A = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_101A{{endif}} + {{if 'CU_TARGET_COMPUTE_103A' in found_values}} + + #: Compute device class 12.0. with accelerated features. + CU_TARGET_COMPUTE_103A = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_103A{{endif}} {{if 'CU_TARGET_COMPUTE_120A' in found_values}} + + #: Compute device class 12.1. with accelerated features. CU_TARGET_COMPUTE_120A = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_120A{{endif}} + {{if 'CU_TARGET_COMPUTE_121A' in found_values}} + + #: Compute device class 10.x with family features. + CU_TARGET_COMPUTE_121A = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_121A{{endif}} + {{if 'CU_TARGET_COMPUTE_100F' in found_values}} + + #: Compute device class 10.1 with family features. + CU_TARGET_COMPUTE_100F = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_100F{{endif}} + {{if 'CU_TARGET_COMPUTE_101F' in found_values}} + + #: Compute device class 10.3. with family features. + CU_TARGET_COMPUTE_101F = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_101F{{endif}} + {{if 'CU_TARGET_COMPUTE_103F' in found_values}} + + #: Compute device class 12.0. with family features. + CU_TARGET_COMPUTE_103F = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_103F{{endif}} + {{if 'CU_TARGET_COMPUTE_120F' in found_values}} + + #: Compute device class 12.1. with family features. + CU_TARGET_COMPUTE_120F = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_120F{{endif}} + {{if 'CU_TARGET_COMPUTE_121F' in found_values}} + CU_TARGET_COMPUTE_121F = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_121F{{endif}} _dict_CUjit_target = dict(((int(v), v) for k, v in CUjit_target.__members__.items())) {{endif}} @@ -3288,6 +3345,10 @@ class CUcigDataType(IntEnum): """ {{if 'CIG_DATA_TYPE_D3D12_COMMAND_QUEUE' in found_values}} CIG_DATA_TYPE_D3D12_COMMAND_QUEUE = cydriver.CUcigDataType_enum.CIG_DATA_TYPE_D3D12_COMMAND_QUEUE{{endif}} + {{if 'CIG_DATA_TYPE_NV_BLOB' in found_values}} + + #: D3D12 Command Queue Handle + CIG_DATA_TYPE_NV_BLOB = cydriver.CUcigDataType_enum.CIG_DATA_TYPE_NV_BLOB{{endif}} _dict_CUcigDataType = dict(((int(v), v) for k, v in CUcigDataType.__members__.items())) {{endif}} @@ -4651,292 +4712,6 @@ class CUmemPool_attribute(IntEnum): _dict_CUmemPool_attribute = dict(((int(v), v) for k, v in CUmemPool_attribute.__members__.items())) {{endif}} -{{if 'CUgraphMem_attribute_enum' in found_types}} - -class CUgraphMem_attribute(IntEnum): - """ - - """ - {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT' in found_values}} - - #: (value type = cuuint64_t) Amount of memory, in bytes, currently - #: associated with graphs - CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT{{endif}} - {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_HIGH' in found_values}} - - #: (value type = cuuint64_t) High watermark of memory, in bytes, - #: associated with graphs since the last time it was reset. High - #: watermark can only be reset to zero. - CU_GRAPH_MEM_ATTR_USED_MEM_HIGH = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH{{endif}} - {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT' in found_values}} - - #: (value type = cuuint64_t) Amount of memory, in bytes, currently - #: allocated for use by the CUDA graphs asynchronous allocator. - CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT{{endif}} - {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH' in found_values}} - - #: (value type = cuuint64_t) High watermark of memory, in bytes, - #: currently allocated for use by the CUDA graphs asynchronous - #: allocator. - CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH{{endif}} - -_dict_CUgraphMem_attribute = dict(((int(v), v) for k, v in CUgraphMem_attribute.__members__.items())) -{{endif}} -{{if 'CUflushGPUDirectRDMAWritesOptions_enum' in found_types}} - -class CUflushGPUDirectRDMAWritesOptions(IntEnum): - """ - Bitmasks for - :py:obj:`~.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS` - """ - {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST' in found_values}} - - #: :py:obj:`~.cuFlushGPUDirectRDMAWrites()` and its CUDA Runtime API - #: counterpart are supported on the device. - CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST = cydriver.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST{{endif}} - {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS' in found_values}} - - #: The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the - #: :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported - #: on the device. - CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS = cydriver.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS{{endif}} - -_dict_CUflushGPUDirectRDMAWritesOptions = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesOptions.__members__.items())) -{{endif}} -{{if 'CUGPUDirectRDMAWritesOrdering_enum' in found_types}} - -class CUGPUDirectRDMAWritesOrdering(IntEnum): - """ - Platform native ordering for GPUDirect RDMA writes - """ - {{if 'CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE' in found_values}} - - #: The device does not natively support ordering of remote writes. - #: :py:obj:`~.cuFlushGPUDirectRDMAWrites()` can be leveraged if - #: supported. - CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE{{endif}} - {{if 'CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER' in found_values}} - - #: Natively, the device can consistently consume remote writes, - #: although other CUDA devices may not. - CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER{{endif}} - {{if 'CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES' in found_values}} - - #: Any CUDA device in the system can consistently consume remote writes - #: to this device. - CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES{{endif}} - -_dict_CUGPUDirectRDMAWritesOrdering = dict(((int(v), v) for k, v in CUGPUDirectRDMAWritesOrdering.__members__.items())) -{{endif}} -{{if 'CUflushGPUDirectRDMAWritesScope_enum' in found_types}} - -class CUflushGPUDirectRDMAWritesScope(IntEnum): - """ - The scopes for :py:obj:`~.cuFlushGPUDirectRDMAWrites` - """ - {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER' in found_values}} - - #: Blocks until remote writes are visible to the CUDA device context - #: owning the data. - CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER = cydriver.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER{{endif}} - {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES' in found_values}} - - #: Blocks until remote writes are visible to all CUDA device contexts. - CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES = cydriver.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES{{endif}} - -_dict_CUflushGPUDirectRDMAWritesScope = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesScope.__members__.items())) -{{endif}} -{{if 'CUflushGPUDirectRDMAWritesTarget_enum' in found_types}} - -class CUflushGPUDirectRDMAWritesTarget(IntEnum): - """ - The targets for :py:obj:`~.cuFlushGPUDirectRDMAWrites` - """ - {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX' in found_values}} - - #: Sets the target for :py:obj:`~.cuFlushGPUDirectRDMAWrites()` to the - #: currently active CUDA device context. - CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX = cydriver.CUflushGPUDirectRDMAWritesTarget_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX{{endif}} - -_dict_CUflushGPUDirectRDMAWritesTarget = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesTarget.__members__.items())) -{{endif}} -{{if 'CUgraphDebugDot_flags_enum' in found_types}} - -class CUgraphDebugDot_flags(IntEnum): - """ - The additional write options for :py:obj:`~.cuGraphDebugDotPrint` - """ - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE' in found_values}} - - #: Output all debug data as if every debug flag is enabled - CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES' in found_values}} - - #: Use CUDA Runtime structures for output - CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS' in found_values}} - - #: Adds CUDA_KERNEL_NODE_PARAMS values to output - CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS' in found_values}} - - #: Adds CUDA_MEMCPY3D values to output - CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS' in found_values}} - - #: Adds CUDA_MEMSET_NODE_PARAMS values to output - CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS' in found_values}} - - #: Adds CUDA_HOST_NODE_PARAMS values to output - CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS' in found_values}} - - #: Adds CUevent handle from record and wait nodes to output - CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS' in found_values}} - - #: Adds CUDA_EXT_SEM_SIGNAL_NODE_PARAMS values to output - CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS' in found_values}} - - #: Adds CUDA_EXT_SEM_WAIT_NODE_PARAMS values to output - CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES' in found_values}} - - #: Adds CUkernelNodeAttrValue values to output - CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES' in found_values}} - - #: Adds node handles and every kernel function handle to output - CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS' in found_values}} - - #: Adds memory alloc node parameters to output - CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS' in found_values}} - - #: Adds memory free node parameters to output - CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS' in found_values}} - - #: Adds batch mem op node parameters to output - CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EXTRA_TOPO_INFO' in found_values}} - - #: Adds edge numbering information - CU_GRAPH_DEBUG_DOT_FLAGS_EXTRA_TOPO_INFO = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXTRA_TOPO_INFO{{endif}} - {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS' in found_values}} - - #: Adds conditional node parameters to output - CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS{{endif}} - -_dict_CUgraphDebugDot_flags = dict(((int(v), v) for k, v in CUgraphDebugDot_flags.__members__.items())) -{{endif}} -{{if 'CUuserObject_flags_enum' in found_types}} - -class CUuserObject_flags(IntEnum): - """ - Flags for user objects for graphs - """ - {{if 'CU_USER_OBJECT_NO_DESTRUCTOR_SYNC' in found_values}} - - #: Indicates the destructor execution is not synchronized by any CUDA - #: handle. - CU_USER_OBJECT_NO_DESTRUCTOR_SYNC = cydriver.CUuserObject_flags_enum.CU_USER_OBJECT_NO_DESTRUCTOR_SYNC{{endif}} - -_dict_CUuserObject_flags = dict(((int(v), v) for k, v in CUuserObject_flags.__members__.items())) -{{endif}} -{{if 'CUuserObjectRetain_flags_enum' in found_types}} - -class CUuserObjectRetain_flags(IntEnum): - """ - Flags for retaining user object references for graphs - """ - {{if 'CU_GRAPH_USER_OBJECT_MOVE' in found_values}} - - #: Transfer references from the caller rather than creating new - #: references. - CU_GRAPH_USER_OBJECT_MOVE = cydriver.CUuserObjectRetain_flags_enum.CU_GRAPH_USER_OBJECT_MOVE{{endif}} - -_dict_CUuserObjectRetain_flags = dict(((int(v), v) for k, v in CUuserObjectRetain_flags.__members__.items())) -{{endif}} -{{if 'CUgraphInstantiate_flags_enum' in found_types}} - -class CUgraphInstantiate_flags(IntEnum): - """ - Flags for instantiating a graph - """ - {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH' in found_values}} - - #: Automatically free memory allocated in a graph before relaunching. - CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH{{endif}} - {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD' in found_values}} - - #: Automatically upload the graph after instantiation. Only supported - #: by :py:obj:`~.cuGraphInstantiateWithParams`. The upload will be - #: performed using the stream provided in `instantiateParams`. - CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD{{endif}} - {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH' in found_values}} - - #: Instantiate the graph to be launchable from the device. This flag - #: can only be used on platforms which support unified addressing. This - #: flag cannot be used in conjunction with - #: CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH. - CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH{{endif}} - {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY' in found_values}} - - #: Run the graph using the per-node priority attributes rather than the - #: priority of the stream it is launched into. - CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY{{endif}} - -_dict_CUgraphInstantiate_flags = dict(((int(v), v) for k, v in CUgraphInstantiate_flags.__members__.items())) -{{endif}} -{{if 'CUdeviceNumaConfig_enum' in found_types}} - -class CUdeviceNumaConfig(IntEnum): - """ - CUDA device NUMA configuration - """ - {{if 'CU_DEVICE_NUMA_CONFIG_NONE' in found_values}} - - #: The GPU is not a NUMA node - CU_DEVICE_NUMA_CONFIG_NONE = cydriver.CUdeviceNumaConfig_enum.CU_DEVICE_NUMA_CONFIG_NONE{{endif}} - {{if 'CU_DEVICE_NUMA_CONFIG_NUMA_NODE' in found_values}} - - #: The GPU is a NUMA node, CU_DEVICE_ATTRIBUTE_NUMA_ID contains its - #: NUMA ID - CU_DEVICE_NUMA_CONFIG_NUMA_NODE = cydriver.CUdeviceNumaConfig_enum.CU_DEVICE_NUMA_CONFIG_NUMA_NODE{{endif}} - -_dict_CUdeviceNumaConfig = dict(((int(v), v) for k, v in CUdeviceNumaConfig.__members__.items())) -{{endif}} -{{if 'CUprocessState_enum' in found_types}} - -class CUprocessState(IntEnum): - """ - CUDA Process States - """ - {{if 'CU_PROCESS_STATE_RUNNING' in found_values}} - - #: Default process state - CU_PROCESS_STATE_RUNNING = cydriver.CUprocessState_enum.CU_PROCESS_STATE_RUNNING{{endif}} - {{if 'CU_PROCESS_STATE_LOCKED' in found_values}} - - #: CUDA API locks are taken so further CUDA API calls will block - CU_PROCESS_STATE_LOCKED = cydriver.CUprocessState_enum.CU_PROCESS_STATE_LOCKED{{endif}} - {{if 'CU_PROCESS_STATE_CHECKPOINTED' in found_values}} - - #: Application memory contents have been checkpointed and underlying - #: allocations and device handles have been released - CU_PROCESS_STATE_CHECKPOINTED = cydriver.CUprocessState_enum.CU_PROCESS_STATE_CHECKPOINTED{{endif}} - {{if 'CU_PROCESS_STATE_FAILED' in found_values}} - - #: Application entered an uncorrectable error during the - #: checkpoint/restore process - CU_PROCESS_STATE_FAILED = cydriver.CUprocessState_enum.CU_PROCESS_STATE_FAILED{{endif}} - -_dict_CUprocessState = dict(((int(v), v) for k, v in CUprocessState.__members__.items())) -{{endif}} {{if 'CUmemcpyFlags_enum' in found_types}} class CUmemcpyFlags(IntEnum): @@ -5016,6 +4791,319 @@ class CUmemcpy3DOperandType(IntEnum): _dict_CUmemcpy3DOperandType = dict(((int(v), v) for k, v in CUmemcpy3DOperandType.__members__.items())) {{endif}} +{{if 'CUgraphMem_attribute_enum' in found_types}} + +class CUgraphMem_attribute(IntEnum): + """ + + """ + {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT' in found_values}} + + #: (value type = cuuint64_t) Amount of memory, in bytes, currently + #: associated with graphs + CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT{{endif}} + {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_HIGH' in found_values}} + + #: (value type = cuuint64_t) High watermark of memory, in bytes, + #: associated with graphs since the last time it was reset. High + #: watermark can only be reset to zero. + CU_GRAPH_MEM_ATTR_USED_MEM_HIGH = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH{{endif}} + {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT' in found_values}} + + #: (value type = cuuint64_t) Amount of memory, in bytes, currently + #: allocated for use by the CUDA graphs asynchronous allocator. + CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT{{endif}} + {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH' in found_values}} + + #: (value type = cuuint64_t) High watermark of memory, in bytes, + #: currently allocated for use by the CUDA graphs asynchronous + #: allocator. + CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH{{endif}} + +_dict_CUgraphMem_attribute = dict(((int(v), v) for k, v in CUgraphMem_attribute.__members__.items())) +{{endif}} +{{if 'CUgraphChildGraphNodeOwnership_enum' in found_types}} + +class CUgraphChildGraphNodeOwnership(IntEnum): + """ + Child graph node ownership + """ + {{if 'CU_GRAPH_CHILD_GRAPH_OWNERSHIP_CLONE' in found_values}} + + #: Default behavior for a child graph node. Child graph is cloned into + #: the parent and memory allocation/free nodes can't be present in the + #: child graph. + CU_GRAPH_CHILD_GRAPH_OWNERSHIP_CLONE = cydriver.CUgraphChildGraphNodeOwnership_enum.CU_GRAPH_CHILD_GRAPH_OWNERSHIP_CLONE{{endif}} + {{if 'CU_GRAPH_CHILD_GRAPH_OWNERSHIP_MOVE' in found_values}} + + #: The child graph is moved to the parent. The handle to the child + #: graph is owned by the parent and will be destroyed when the parent + #: is destroyed. + #: + #: The following restrictions apply to child graphs after they have + #: been moved: Cannot be independently instantiated or destroyed; + #: Cannot be added as a child graph of a separate parent graph; Cannot + #: be used as an argument to cuGraphExecUpdate; Cannot have additional + #: memory allocation or free nodes added. + CU_GRAPH_CHILD_GRAPH_OWNERSHIP_MOVE = cydriver.CUgraphChildGraphNodeOwnership_enum.CU_GRAPH_CHILD_GRAPH_OWNERSHIP_MOVE{{endif}} + +_dict_CUgraphChildGraphNodeOwnership = dict(((int(v), v) for k, v in CUgraphChildGraphNodeOwnership.__members__.items())) +{{endif}} +{{if 'CUflushGPUDirectRDMAWritesOptions_enum' in found_types}} + +class CUflushGPUDirectRDMAWritesOptions(IntEnum): + """ + Bitmasks for + :py:obj:`~.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS` + """ + {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST' in found_values}} + + #: :py:obj:`~.cuFlushGPUDirectRDMAWrites()` and its CUDA Runtime API + #: counterpart are supported on the device. + CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST = cydriver.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST{{endif}} + {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS' in found_values}} + + #: The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the + #: :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported + #: on the device. + CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS = cydriver.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS{{endif}} + +_dict_CUflushGPUDirectRDMAWritesOptions = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesOptions.__members__.items())) +{{endif}} +{{if 'CUGPUDirectRDMAWritesOrdering_enum' in found_types}} + +class CUGPUDirectRDMAWritesOrdering(IntEnum): + """ + Platform native ordering for GPUDirect RDMA writes + """ + {{if 'CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE' in found_values}} + + #: The device does not natively support ordering of remote writes. + #: :py:obj:`~.cuFlushGPUDirectRDMAWrites()` can be leveraged if + #: supported. + CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE{{endif}} + {{if 'CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER' in found_values}} + + #: Natively, the device can consistently consume remote writes, + #: although other CUDA devices may not. + CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER{{endif}} + {{if 'CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES' in found_values}} + + #: Any CUDA device in the system can consistently consume remote writes + #: to this device. + CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES{{endif}} + +_dict_CUGPUDirectRDMAWritesOrdering = dict(((int(v), v) for k, v in CUGPUDirectRDMAWritesOrdering.__members__.items())) +{{endif}} +{{if 'CUflushGPUDirectRDMAWritesScope_enum' in found_types}} + +class CUflushGPUDirectRDMAWritesScope(IntEnum): + """ + The scopes for :py:obj:`~.cuFlushGPUDirectRDMAWrites` + """ + {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER' in found_values}} + + #: Blocks until remote writes are visible to the CUDA device context + #: owning the data. + CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER = cydriver.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER{{endif}} + {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES' in found_values}} + + #: Blocks until remote writes are visible to all CUDA device contexts. + CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES = cydriver.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES{{endif}} + +_dict_CUflushGPUDirectRDMAWritesScope = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesScope.__members__.items())) +{{endif}} +{{if 'CUflushGPUDirectRDMAWritesTarget_enum' in found_types}} + +class CUflushGPUDirectRDMAWritesTarget(IntEnum): + """ + The targets for :py:obj:`~.cuFlushGPUDirectRDMAWrites` + """ + {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX' in found_values}} + + #: Sets the target for :py:obj:`~.cuFlushGPUDirectRDMAWrites()` to the + #: currently active CUDA device context. + CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX = cydriver.CUflushGPUDirectRDMAWritesTarget_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX{{endif}} + +_dict_CUflushGPUDirectRDMAWritesTarget = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesTarget.__members__.items())) +{{endif}} +{{if 'CUgraphDebugDot_flags_enum' in found_types}} + +class CUgraphDebugDot_flags(IntEnum): + """ + The additional write options for :py:obj:`~.cuGraphDebugDotPrint` + """ + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE' in found_values}} + + #: Output all debug data as if every debug flag is enabled + CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES' in found_values}} + + #: Use CUDA Runtime structures for output + CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS' in found_values}} + + #: Adds CUDA_KERNEL_NODE_PARAMS values to output + CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS' in found_values}} + + #: Adds CUDA_MEMCPY3D values to output + CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS' in found_values}} + + #: Adds CUDA_MEMSET_NODE_PARAMS values to output + CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS' in found_values}} + + #: Adds CUDA_HOST_NODE_PARAMS values to output + CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS' in found_values}} + + #: Adds CUevent handle from record and wait nodes to output + CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS' in found_values}} + + #: Adds CUDA_EXT_SEM_SIGNAL_NODE_PARAMS values to output + CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS' in found_values}} + + #: Adds CUDA_EXT_SEM_WAIT_NODE_PARAMS values to output + CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES' in found_values}} + + #: Adds CUkernelNodeAttrValue values to output + CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES' in found_values}} + + #: Adds node handles and every kernel function handle to output + CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS' in found_values}} + + #: Adds memory alloc node parameters to output + CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS' in found_values}} + + #: Adds memory free node parameters to output + CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS' in found_values}} + + #: Adds batch mem op node parameters to output + CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EXTRA_TOPO_INFO' in found_values}} + + #: Adds edge numbering information + CU_GRAPH_DEBUG_DOT_FLAGS_EXTRA_TOPO_INFO = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXTRA_TOPO_INFO{{endif}} + {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS' in found_values}} + + #: Adds conditional node parameters to output + CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS{{endif}} + +_dict_CUgraphDebugDot_flags = dict(((int(v), v) for k, v in CUgraphDebugDot_flags.__members__.items())) +{{endif}} +{{if 'CUuserObject_flags_enum' in found_types}} + +class CUuserObject_flags(IntEnum): + """ + Flags for user objects for graphs + """ + {{if 'CU_USER_OBJECT_NO_DESTRUCTOR_SYNC' in found_values}} + + #: Indicates the destructor execution is not synchronized by any CUDA + #: handle. + CU_USER_OBJECT_NO_DESTRUCTOR_SYNC = cydriver.CUuserObject_flags_enum.CU_USER_OBJECT_NO_DESTRUCTOR_SYNC{{endif}} + +_dict_CUuserObject_flags = dict(((int(v), v) for k, v in CUuserObject_flags.__members__.items())) +{{endif}} +{{if 'CUuserObjectRetain_flags_enum' in found_types}} + +class CUuserObjectRetain_flags(IntEnum): + """ + Flags for retaining user object references for graphs + """ + {{if 'CU_GRAPH_USER_OBJECT_MOVE' in found_values}} + + #: Transfer references from the caller rather than creating new + #: references. + CU_GRAPH_USER_OBJECT_MOVE = cydriver.CUuserObjectRetain_flags_enum.CU_GRAPH_USER_OBJECT_MOVE{{endif}} + +_dict_CUuserObjectRetain_flags = dict(((int(v), v) for k, v in CUuserObjectRetain_flags.__members__.items())) +{{endif}} +{{if 'CUgraphInstantiate_flags_enum' in found_types}} + +class CUgraphInstantiate_flags(IntEnum): + """ + Flags for instantiating a graph + """ + {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH' in found_values}} + + #: Automatically free memory allocated in a graph before relaunching. + CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH{{endif}} + {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD' in found_values}} + + #: Automatically upload the graph after instantiation. Only supported + #: by :py:obj:`~.cuGraphInstantiateWithParams`. The upload will be + #: performed using the stream provided in `instantiateParams`. + CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD{{endif}} + {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH' in found_values}} + + #: Instantiate the graph to be launchable from the device. This flag + #: can only be used on platforms which support unified addressing. This + #: flag cannot be used in conjunction with + #: CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH. + CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH{{endif}} + {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY' in found_values}} + + #: Run the graph using the per-node priority attributes rather than the + #: priority of the stream it is launched into. + CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY{{endif}} + +_dict_CUgraphInstantiate_flags = dict(((int(v), v) for k, v in CUgraphInstantiate_flags.__members__.items())) +{{endif}} +{{if 'CUdeviceNumaConfig_enum' in found_types}} + +class CUdeviceNumaConfig(IntEnum): + """ + CUDA device NUMA configuration + """ + {{if 'CU_DEVICE_NUMA_CONFIG_NONE' in found_values}} + + #: The GPU is not a NUMA node + CU_DEVICE_NUMA_CONFIG_NONE = cydriver.CUdeviceNumaConfig_enum.CU_DEVICE_NUMA_CONFIG_NONE{{endif}} + {{if 'CU_DEVICE_NUMA_CONFIG_NUMA_NODE' in found_values}} + + #: The GPU is a NUMA node, CU_DEVICE_ATTRIBUTE_NUMA_ID contains its + #: NUMA ID + CU_DEVICE_NUMA_CONFIG_NUMA_NODE = cydriver.CUdeviceNumaConfig_enum.CU_DEVICE_NUMA_CONFIG_NUMA_NODE{{endif}} + +_dict_CUdeviceNumaConfig = dict(((int(v), v) for k, v in CUdeviceNumaConfig.__members__.items())) +{{endif}} +{{if 'CUprocessState_enum' in found_types}} + +class CUprocessState(IntEnum): + """ + CUDA Process States + """ + {{if 'CU_PROCESS_STATE_RUNNING' in found_values}} + + #: Default process state + CU_PROCESS_STATE_RUNNING = cydriver.CUprocessState_enum.CU_PROCESS_STATE_RUNNING{{endif}} + {{if 'CU_PROCESS_STATE_LOCKED' in found_values}} + + #: CUDA API locks are taken so further CUDA API calls will block + CU_PROCESS_STATE_LOCKED = cydriver.CUprocessState_enum.CU_PROCESS_STATE_LOCKED{{endif}} + {{if 'CU_PROCESS_STATE_CHECKPOINTED' in found_values}} + + #: Application memory contents have been checkpointed and underlying + #: allocations and device handles have been released + CU_PROCESS_STATE_CHECKPOINTED = cydriver.CUprocessState_enum.CU_PROCESS_STATE_CHECKPOINTED{{endif}} + {{if 'CU_PROCESS_STATE_FAILED' in found_values}} + + #: Application entered an uncorrectable error during the + #: checkpoint/restore process + CU_PROCESS_STATE_FAILED = cydriver.CUprocessState_enum.CU_PROCESS_STATE_FAILED{{endif}} + +_dict_CUprocessState = dict(((int(v), v) for k, v in CUprocessState.__members__.items())) +{{endif}} {{if 'CUmoduleLoadingMode_enum' in found_types}} class CUmoduleLoadingMode(IntEnum): @@ -5051,6 +5139,10 @@ class CUmemDecompressAlgorithm(IntEnum): #: Snappy is supported. CU_MEM_DECOMPRESS_ALGORITHM_SNAPPY = cydriver.CUmemDecompressAlgorithm_enum.CU_MEM_DECOMPRESS_ALGORITHM_SNAPPY{{endif}} + {{if 'CU_MEM_DECOMPRESS_ALGORITHM_LZ4' in found_values}} + + #: LZ4 is supported. + CU_MEM_DECOMPRESS_ALGORITHM_LZ4 = cydriver.CUmemDecompressAlgorithm_enum.CU_MEM_DECOMPRESS_ALGORITHM_LZ4{{endif}} _dict_CUmemDecompressAlgorithm = dict(((int(v), v) for k, v in CUmemDecompressAlgorithm.__members__.items())) {{endif}} @@ -5160,6 +5252,19 @@ class CUdevResourceType(IntEnum): _dict_CUdevResourceType = dict(((int(v), v) for k, v in CUdevResourceType.__members__.items())) {{endif}} +{{if 'CUlogLevel_enum' in found_types}} + +class CUlogLevel(IntEnum): + """ + + """ + {{if 'CU_LOG_LEVEL_ERROR' in found_values}} + CU_LOG_LEVEL_ERROR = cydriver.CUlogLevel_enum.CU_LOG_LEVEL_ERROR{{endif}} + {{if 'CU_LOG_LEVEL_WARNING' in found_values}} + CU_LOG_LEVEL_WARNING = cydriver.CUlogLevel_enum.CU_LOG_LEVEL_WARNING{{endif}} + +_dict_CUlogLevel = dict(((int(v), v) for k, v in CUlogLevel.__members__.items())) +{{endif}} {{if 'CUoutput_mode_enum' in found_types}} class CUoutput_mode(IntEnum): @@ -7141,6 +7246,35 @@ cdef class CUdevResourceDesc: return self._pvt_ptr {{endif}} +{{if 'CUlogsCallbackHandle' in found_types}} + +cdef class CUlogsCallbackHandle: + """ + + 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] = init_value + else: + self._pvt_ptr = _ptr + def __init__(self, *args, **kwargs): + pass + def __repr__(self): + return '' + def __index__(self): + return self.__int__() + def __int__(self): + return self._pvt_ptr[0] + def getPtr(self): + return self._pvt_ptr +{{endif}} + {{if True}} cdef class CUeglStreamConnection: @@ -7375,6 +7509,35 @@ cdef class CUoccupancyB2DSize: return self._pvt_ptr {{endif}} +{{if 'CUlogsCallback' in found_types}} + +cdef class CUlogsCallback: + """ + + 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] = init_value + else: + self._pvt_ptr = _ptr + def __init__(self, *args, **kwargs): + pass + def __repr__(self): + return '' + def __index__(self): + return self.__int__() + def __int__(self): + return self._pvt_ptr[0] + def getPtr(self): + return self._pvt_ptr +{{endif}} + {{if 'CUuuid_st' in found_struct}} cdef class CUuuid_st: @@ -8056,7 +8219,7 @@ cdef class CUstreamMemOpMemoryBarrierParams_st: {{endif}} {{if 'CUstreamBatchMemOpParams_union.memoryBarrier.flags' in found_struct}} flags : unsigned int - + See CUstreamMemoryBarrier_flags {{endif}} Methods @@ -8638,11 +8801,12 @@ cdef class CUasyncNotificationInfo_st: ---------- {{if 'CUasyncNotificationInfo_st.type' in found_struct}} type : CUasyncNotificationType - + The type of notification being sent {{endif}} {{if 'CUasyncNotificationInfo_st.info' in found_struct}} info : anon_union2 - + Information about the notification. `typename` must be checked in + order to interpret this field. {{endif}} Methods @@ -19558,37 +19722,33 @@ cdef class CUmemPoolPtrExportData_st: self._pvt_ptr[0].reserved[i] = b {{endif}} {{endif}} -{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st' in found_struct}} +{{if 'CUmemcpyAttributes_st' in found_struct}} -cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1_st: +cdef class CUmemcpyAttributes_st: """ - Memory allocation node parameters + Attributes specific to copies within a batch. For more details on + usage see cuMemcpyBatchAsync. Attributes ---------- - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} - poolProps : CUmemPoolProps - in: location where the allocation should reside (specified in - ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is - not supported. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} - accessDescs : CUmemAccessDesc - in: array of memory access descriptors. Used to describe peer GPU - access + {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} + srcAccessOrder : CUmemcpySrcAccessOrder + Source access ordering to be observed for copies with this + attribute. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} - accessDescCount : size_t - in: number of memory access descriptors. Must not exceed the number - of GPUs. + {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} + srcLocHint : CUmemLocation + Hint location for the source operand. Ignored when the pointers are + not managed memory or memory allocated outside CUDA. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} - bytesize : size_t - in: size in bytes of the requested allocation + {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} + dstLocHint : CUmemLocation + Hint location for the destination operand. Ignored when the + pointers are not managed memory or memory allocated outside CUDA. {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} - dptr : CUdeviceptr - out: address of the allocation returned by CUDA + {{if 'CUmemcpyAttributes_st.flags' in found_struct}} + flags : unsigned int + Additional flags for copies with this attribute. See CUmemcpyFlags {{endif}} Methods @@ -19600,156 +19760,103 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} - self._poolProps = CUmemPoolProps(_ptr=&self._pvt_ptr[0].poolProps) + {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} + self._srcLocHint = CUmemLocation(_ptr=&self._pvt_ptr[0].srcLocHint) {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} - self._dptr = CUdeviceptr(_ptr=&self._pvt_ptr[0].dptr) + {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} + self._dstLocHint = CUmemLocation(_ptr=&self._pvt_ptr[0].dstLocHint) {{endif}} def __dealloc__(self): pass - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} - if self._accessDescs is not NULL: - free(self._accessDescs) - {{endif}} def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} - try: - str_list += ['poolProps :\n' + '\n'.join([' ' + line for line in str(self.poolProps).splitlines()])] - except ValueError: - str_list += ['poolProps : '] - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} try: - str_list += ['accessDescs : ' + str(self.accessDescs)] + str_list += ['srcAccessOrder : ' + str(self.srcAccessOrder)] except ValueError: - str_list += ['accessDescs : '] + str_list += ['srcAccessOrder : '] {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} + {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} try: - str_list += ['accessDescCount : ' + str(self.accessDescCount)] + str_list += ['srcLocHint :\n' + '\n'.join([' ' + line for line in str(self.srcLocHint).splitlines()])] except ValueError: - str_list += ['accessDescCount : '] + str_list += ['srcLocHint : '] {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} + {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} try: - str_list += ['bytesize : ' + str(self.bytesize)] + str_list += ['dstLocHint :\n' + '\n'.join([' ' + line for line in str(self.dstLocHint).splitlines()])] except ValueError: - str_list += ['bytesize : '] + str_list += ['dstLocHint : '] {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + {{if 'CUmemcpyAttributes_st.flags' in found_struct}} try: - str_list += ['dptr : ' + str(self.dptr)] + str_list += ['flags : ' + str(self.flags)] except ValueError: - str_list += ['dptr : '] + str_list += ['flags : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} - @property - def poolProps(self): - return self._poolProps - @poolProps.setter - def poolProps(self, poolProps not None : CUmemPoolProps): - string.memcpy(&self._pvt_ptr[0].poolProps, poolProps.getPtr(), sizeof(self._pvt_ptr[0].poolProps)) - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} @property - def accessDescs(self): - arrs = [self._pvt_ptr[0].accessDescs + x*sizeof(cydriver.CUmemAccessDesc) for x in range(self._accessDescs_length)] - return [CUmemAccessDesc(_ptr=arr) for arr in arrs] - @accessDescs.setter - def accessDescs(self, val): - if len(val) == 0: - free(self._accessDescs) - self._accessDescs_length = 0 - self._pvt_ptr[0].accessDescs = NULL - else: - if self._accessDescs_length != len(val): - free(self._accessDescs) - self._accessDescs = calloc(len(val), sizeof(cydriver.CUmemAccessDesc)) - if self._accessDescs is NULL: - raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUmemAccessDesc))) - self._accessDescs_length = len(val) - self._pvt_ptr[0].accessDescs = self._accessDescs - for idx in range(len(val)): - string.memcpy(&self._accessDescs[idx], (val[idx])._pvt_ptr, sizeof(cydriver.CUmemAccessDesc)) - + def srcAccessOrder(self): + if self._pvt_ptr[0].srcAccessOrder not in _dict_CUmemcpySrcAccessOrder: + return None + return _dict_CUmemcpySrcAccessOrder[self._pvt_ptr[0].srcAccessOrder] + @srcAccessOrder.setter + def srcAccessOrder(self, srcAccessOrder not None : CUmemcpySrcAccessOrder): + self._pvt_ptr[0].srcAccessOrder = srcAccessOrder.value {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} + {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} @property - def accessDescCount(self): - return self._pvt_ptr[0].accessDescCount - @accessDescCount.setter - def accessDescCount(self, size_t accessDescCount): - self._pvt_ptr[0].accessDescCount = accessDescCount + def srcLocHint(self): + return self._srcLocHint + @srcLocHint.setter + def srcLocHint(self, srcLocHint not None : CUmemLocation): + string.memcpy(&self._pvt_ptr[0].srcLocHint, srcLocHint.getPtr(), sizeof(self._pvt_ptr[0].srcLocHint)) {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} + {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} @property - def bytesize(self): - return self._pvt_ptr[0].bytesize - @bytesize.setter - def bytesize(self, size_t bytesize): - self._pvt_ptr[0].bytesize = bytesize + def dstLocHint(self): + return self._dstLocHint + @dstLocHint.setter + def dstLocHint(self, dstLocHint not None : CUmemLocation): + string.memcpy(&self._pvt_ptr[0].dstLocHint, dstLocHint.getPtr(), sizeof(self._pvt_ptr[0].dstLocHint)) {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + {{if 'CUmemcpyAttributes_st.flags' in found_struct}} @property - def dptr(self): - return self._dptr - @dptr.setter - def dptr(self, dptr): - cdef cydriver.CUdeviceptr cydptr - if dptr is None: - cydptr = 0 - elif isinstance(dptr, (CUdeviceptr)): - pdptr = int(dptr) - cydptr = pdptr - else: - pdptr = int(CUdeviceptr(dptr)) - cydptr = pdptr - self._dptr._pvt_ptr[0] = cydptr - + def flags(self): + return self._pvt_ptr[0].flags + @flags.setter + def flags(self, unsigned int flags): + self._pvt_ptr[0].flags = flags {{endif}} {{endif}} -{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st' in found_struct}} +{{if 'CUoffset3D_st' in found_struct}} -cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2_st: +cdef class CUoffset3D_st: """ - Memory allocation node parameters + Struct representing offset into a CUarray in elements Attributes ---------- - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} - poolProps : CUmemPoolProps - in: location where the allocation should reside (specified in - ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is - not supported. - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} - accessDescs : CUmemAccessDesc - in: array of memory access descriptors. Used to describe peer GPU - access - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} - accessDescCount : size_t - in: number of memory access descriptors. Must not exceed the number - of GPUs. + {{if 'CUoffset3D_st.x' in found_struct}} + x : size_t + {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} - bytesize : size_t - in: size in bytes of the requested allocation + {{if 'CUoffset3D_st.y' in found_struct}} + y : size_t + {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} - dptr : CUdeviceptr - out: address of the allocation returned by CUDA + {{if 'CUoffset3D_st.z' in found_struct}} + z : size_t + {{endif}} Methods @@ -19761,136 +19868,81 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} - self._poolProps = CUmemPoolProps(_ptr=&self._pvt_ptr[0].poolProps) - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} - self._dptr = CUdeviceptr(_ptr=&self._pvt_ptr[0].dptr) - {{endif}} def __dealloc__(self): pass - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} - if self._accessDescs is not NULL: - free(self._accessDescs) - {{endif}} def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} - try: - str_list += ['poolProps :\n' + '\n'.join([' ' + line for line in str(self.poolProps).splitlines()])] - except ValueError: - str_list += ['poolProps : '] - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} - try: - str_list += ['accessDescs : ' + str(self.accessDescs)] - except ValueError: - str_list += ['accessDescs : '] - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} + {{if 'CUoffset3D_st.x' in found_struct}} try: - str_list += ['accessDescCount : ' + str(self.accessDescCount)] + str_list += ['x : ' + str(self.x)] except ValueError: - str_list += ['accessDescCount : '] + str_list += ['x : '] {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} + {{if 'CUoffset3D_st.y' in found_struct}} try: - str_list += ['bytesize : ' + str(self.bytesize)] + str_list += ['y : ' + str(self.y)] except ValueError: - str_list += ['bytesize : '] + str_list += ['y : '] {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + {{if 'CUoffset3D_st.z' in found_struct}} try: - str_list += ['dptr : ' + str(self.dptr)] + str_list += ['z : ' + str(self.z)] except ValueError: - str_list += ['dptr : '] + str_list += ['z : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} - @property - def poolProps(self): - return self._poolProps - @poolProps.setter - def poolProps(self, poolProps not None : CUmemPoolProps): - string.memcpy(&self._pvt_ptr[0].poolProps, poolProps.getPtr(), sizeof(self._pvt_ptr[0].poolProps)) - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} - @property - def accessDescs(self): - arrs = [self._pvt_ptr[0].accessDescs + x*sizeof(cydriver.CUmemAccessDesc) for x in range(self._accessDescs_length)] - return [CUmemAccessDesc(_ptr=arr) for arr in arrs] - @accessDescs.setter - def accessDescs(self, val): - if len(val) == 0: - free(self._accessDescs) - self._accessDescs_length = 0 - self._pvt_ptr[0].accessDescs = NULL - else: - if self._accessDescs_length != len(val): - free(self._accessDescs) - self._accessDescs = calloc(len(val), sizeof(cydriver.CUmemAccessDesc)) - if self._accessDescs is NULL: - raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUmemAccessDesc))) - self._accessDescs_length = len(val) - self._pvt_ptr[0].accessDescs = self._accessDescs - for idx in range(len(val)): - string.memcpy(&self._accessDescs[idx], (val[idx])._pvt_ptr, sizeof(cydriver.CUmemAccessDesc)) - - {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} + {{if 'CUoffset3D_st.x' in found_struct}} @property - def accessDescCount(self): - return self._pvt_ptr[0].accessDescCount - @accessDescCount.setter - def accessDescCount(self, size_t accessDescCount): - self._pvt_ptr[0].accessDescCount = accessDescCount + def x(self): + return self._pvt_ptr[0].x + @x.setter + def x(self, size_t x): + self._pvt_ptr[0].x = x {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} + {{if 'CUoffset3D_st.y' in found_struct}} @property - def bytesize(self): - return self._pvt_ptr[0].bytesize - @bytesize.setter - def bytesize(self, size_t bytesize): - self._pvt_ptr[0].bytesize = bytesize + def y(self): + return self._pvt_ptr[0].y + @y.setter + def y(self, size_t y): + self._pvt_ptr[0].y = y {{endif}} - {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + {{if 'CUoffset3D_st.z' in found_struct}} @property - def dptr(self): - return self._dptr - @dptr.setter - def dptr(self, dptr): - cdef cydriver.CUdeviceptr cydptr - if dptr is None: - cydptr = 0 - elif isinstance(dptr, (CUdeviceptr)): - pdptr = int(dptr) - cydptr = pdptr - else: - pdptr = int(CUdeviceptr(dptr)) - cydptr = pdptr - self._dptr._pvt_ptr[0] = cydptr - + def z(self): + return self._pvt_ptr[0].z + @z.setter + def z(self, size_t z): + self._pvt_ptr[0].z = z {{endif}} {{endif}} -{{if 'CUDA_MEM_FREE_NODE_PARAMS_st' in found_struct}} +{{if 'CUextent3D_st' in found_struct}} -cdef class CUDA_MEM_FREE_NODE_PARAMS_st: +cdef class CUextent3D_st: """ - Memory free node parameters + Struct representing width/height/depth of a CUarray in elements Attributes ---------- - {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} - dptr : CUdeviceptr - in: the pointer to free + {{if 'CUextent3D_st.width' in found_struct}} + width : size_t + + {{endif}} + {{if 'CUextent3D_st.height' in found_struct}} + height : size_t + + {{endif}} + {{if 'CUextent3D_st.depth' in found_struct}} + depth : size_t + {{endif}} Methods @@ -19902,12 +19954,9 @@ cdef class CUDA_MEM_FREE_NODE_PARAMS_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} - self._dptr = CUdeviceptr(_ptr=&self._pvt_ptr[0].dptr) - {{endif}} def __dealloc__(self): pass def getPtr(self): @@ -19915,46 +19964,73 @@ cdef class CUDA_MEM_FREE_NODE_PARAMS_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} + {{if 'CUextent3D_st.width' in found_struct}} try: - str_list += ['dptr : ' + str(self.dptr)] + str_list += ['width : ' + str(self.width)] except ValueError: - str_list += ['dptr : '] + str_list += ['width : '] + {{endif}} + {{if 'CUextent3D_st.height' in found_struct}} + try: + str_list += ['height : ' + str(self.height)] + except ValueError: + str_list += ['height : '] + {{endif}} + {{if 'CUextent3D_st.depth' in found_struct}} + try: + str_list += ['depth : ' + str(self.depth)] + except ValueError: + str_list += ['depth : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} + {{if 'CUextent3D_st.width' in found_struct}} @property - def dptr(self): - return self._dptr - @dptr.setter - def dptr(self, dptr): - cdef cydriver.CUdeviceptr cydptr - if dptr is None: - cydptr = 0 - elif isinstance(dptr, (CUdeviceptr)): - pdptr = int(dptr) - cydptr = pdptr - else: - pdptr = int(CUdeviceptr(dptr)) - cydptr = pdptr - self._dptr._pvt_ptr[0] = cydptr - + def width(self): + return self._pvt_ptr[0].width + @width.setter + def width(self, size_t width): + self._pvt_ptr[0].width = width + {{endif}} + {{if 'CUextent3D_st.height' in found_struct}} + @property + def height(self): + return self._pvt_ptr[0].height + @height.setter + def height(self, size_t height): + self._pvt_ptr[0].height = height + {{endif}} + {{if 'CUextent3D_st.depth' in found_struct}} + @property + def depth(self): + return self._pvt_ptr[0].depth + @depth.setter + def depth(self, size_t depth): + self._pvt_ptr[0].depth = depth {{endif}} {{endif}} -{{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st' in found_struct}} +{{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} -cdef class CUDA_CHILD_GRAPH_NODE_PARAMS_st: +cdef class anon_struct23: """ - Child graph node parameters - Attributes ---------- - {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} - graph : CUgraph - The child graph to clone into the node for node creation, or a - handle to the graph owned by the node for node query + {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} + ptr : CUdeviceptr + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.rowLength' in found_struct}} + rowLength : size_t + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.layerHeight' in found_struct}} + layerHeight : size_t + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} + locHint : CUmemLocation + {{endif}} Methods @@ -19962,123 +20038,107 @@ cdef class CUDA_CHILD_GRAPH_NODE_PARAMS_st: getPtr() Get memory address of class instance """ - def __cinit__(self, void_ptr _ptr = 0): - if _ptr == 0: - self._pvt_ptr = &self._pvt_val - else: - self._pvt_ptr = _ptr - def __init__(self, void_ptr _ptr = 0): + def __cinit__(self, void_ptr _ptr): + self._pvt_ptr = _ptr + + def __init__(self, void_ptr _ptr): pass - {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} - self._graph = CUgraph(_ptr=&self._pvt_ptr[0].graph) + {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} + self._ptr = CUdeviceptr(_ptr=&self._pvt_ptr[0].op.ptr.ptr) + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} + self._locHint = CUmemLocation(_ptr=&self._pvt_ptr[0].op.ptr.locHint) {{endif}} def __dealloc__(self): pass def getPtr(self): - return self._pvt_ptr + return &self._pvt_ptr[0].op.ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} try: - str_list += ['graph : ' + str(self.graph)] + str_list += ['ptr : ' + str(self.ptr)] except ValueError: - str_list += ['graph : '] + str_list += ['ptr : '] {{endif}} - return '\n'.join(str_list) - else: - return '' - {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} - @property - def graph(self): - return self._graph - @graph.setter - def graph(self, graph): - cdef cydriver.CUgraph cygraph - if graph is None: - cygraph = 0 - elif isinstance(graph, (CUgraph,)): - pgraph = int(graph) - cygraph = pgraph - else: - pgraph = int(CUgraph(graph)) - cygraph = pgraph - self._graph._pvt_ptr[0] = cygraph - {{endif}} -{{endif}} -{{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st' in found_struct}} - -cdef class CUDA_EVENT_RECORD_NODE_PARAMS_st: - """ - Event record node parameters - - Attributes - ---------- - {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} - event : CUevent - The event to record when the node executes - {{endif}} - - Methods - ------- - getPtr() - Get memory address of class instance - """ - def __cinit__(self, void_ptr _ptr = 0): - if _ptr == 0: - self._pvt_ptr = &self._pvt_val - else: - self._pvt_ptr = _ptr - def __init__(self, void_ptr _ptr = 0): - pass - {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} - self._event = CUevent(_ptr=&self._pvt_ptr[0].event) - {{endif}} - def __dealloc__(self): - pass - def getPtr(self): - return self._pvt_ptr - def __repr__(self): - if self._pvt_ptr is not NULL: - str_list = [] - {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.ptr.rowLength' in found_struct}} try: - str_list += ['event : ' + str(self.event)] + str_list += ['rowLength : ' + str(self.rowLength)] except ValueError: - str_list += ['event : '] + str_list += ['rowLength : '] + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.layerHeight' in found_struct}} + try: + str_list += ['layerHeight : ' + str(self.layerHeight)] + except ValueError: + str_list += ['layerHeight : '] + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} + try: + str_list += ['locHint :\n' + '\n'.join([' ' + line for line in str(self.locHint).splitlines()])] + except ValueError: + str_list += ['locHint : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} @property - def event(self): - return self._event - @event.setter - def event(self, event): - cdef cydriver.CUevent cyevent - if event is None: - cyevent = 0 - elif isinstance(event, (CUevent,)): - pevent = int(event) - cyevent = pevent + def ptr(self): + return self._ptr + @ptr.setter + def ptr(self, ptr): + cdef cydriver.CUdeviceptr cyptr + if ptr is None: + cyptr = 0 + elif isinstance(ptr, (CUdeviceptr)): + pptr = int(ptr) + cyptr = pptr else: - pevent = int(CUevent(event)) - cyevent = pevent - self._event._pvt_ptr[0] = cyevent + pptr = int(CUdeviceptr(ptr)) + cyptr = pptr + self._ptr._pvt_ptr[0] = cyptr + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.rowLength' in found_struct}} + @property + def rowLength(self): + return self._pvt_ptr[0].op.ptr.rowLength + @rowLength.setter + def rowLength(self, size_t rowLength): + self._pvt_ptr[0].op.ptr.rowLength = rowLength + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.layerHeight' in found_struct}} + @property + def layerHeight(self): + return self._pvt_ptr[0].op.ptr.layerHeight + @layerHeight.setter + def layerHeight(self, size_t layerHeight): + self._pvt_ptr[0].op.ptr.layerHeight = layerHeight + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} + @property + def locHint(self): + return self._locHint + @locHint.setter + def locHint(self, locHint not None : CUmemLocation): + string.memcpy(&self._pvt_ptr[0].op.ptr.locHint, locHint.getPtr(), sizeof(self._pvt_ptr[0].op.ptr.locHint)) {{endif}} {{endif}} -{{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st' in found_struct}} +{{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} -cdef class CUDA_EVENT_WAIT_NODE_PARAMS_st: +cdef class anon_struct24: """ - Event wait node parameters - Attributes ---------- - {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} - event : CUevent - The event to wait on from the node + {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} + array : CUarray + + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} + offset : CUoffset3D + {{endif}} Methods @@ -20086,125 +20146,78 @@ cdef class CUDA_EVENT_WAIT_NODE_PARAMS_st: getPtr() Get memory address of class instance """ - def __cinit__(self, void_ptr _ptr = 0): - if _ptr == 0: - self._pvt_ptr = &self._pvt_val - else: - self._pvt_ptr = _ptr - def __init__(self, void_ptr _ptr = 0): + def __cinit__(self, void_ptr _ptr): + self._pvt_ptr = _ptr + + def __init__(self, void_ptr _ptr): pass - {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} - self._event = CUevent(_ptr=&self._pvt_ptr[0].event) + {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} + self._array = CUarray(_ptr=&self._pvt_ptr[0].op.array.array) + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} + self._offset = CUoffset3D(_ptr=&self._pvt_ptr[0].op.array.offset) {{endif}} def __dealloc__(self): pass def getPtr(self): - return self._pvt_ptr + return &self._pvt_ptr[0].op.array def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} try: - str_list += ['event : ' + str(self.event)] + str_list += ['array : ' + str(self.array)] except ValueError: - str_list += ['event : '] + str_list += ['array : '] + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} + try: + str_list += ['offset :\n' + '\n'.join([' ' + line for line in str(self.offset).splitlines()])] + except ValueError: + str_list += ['offset : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} @property - def event(self): - return self._event - @event.setter - def event(self, event): - cdef cydriver.CUevent cyevent - if event is None: - cyevent = 0 - elif isinstance(event, (CUevent,)): - pevent = int(event) - cyevent = pevent + def array(self): + return self._array + @array.setter + def array(self, array): + cdef cydriver.CUarray cyarray + if array is None: + cyarray = 0 + elif isinstance(array, (CUarray,)): + parray = int(array) + cyarray = parray else: - pevent = int(CUevent(event)) - cyevent = pevent - self._event._pvt_ptr[0] = cyevent + parray = int(CUarray(array)) + cyarray = parray + self._array._pvt_ptr[0] = cyarray + {{endif}} + {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} + @property + def offset(self): + return self._offset + @offset.setter + def offset(self, offset not None : CUoffset3D): + string.memcpy(&self._pvt_ptr[0].op.array.offset, offset.getPtr(), sizeof(self._pvt_ptr[0].op.array.offset)) {{endif}} {{endif}} -{{if 'CUgraphNodeParams_st' in found_struct}} +{{if 'CUmemcpy3DOperand_st.op' in found_struct}} -cdef class CUgraphNodeParams_st: +cdef class anon_union12: """ - Graph node parameters. See cuGraphAddNode. - Attributes ---------- - {{if 'CUgraphNodeParams_st.type' in found_struct}} - type : CUgraphNodeType - Type of the node - {{endif}} - {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} - reserved0 : List[int] - Reserved. Must be zero. - {{endif}} - {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} - reserved1 : List[long long] - Padding. Unused bytes must be zero. - {{endif}} - {{if 'CUgraphNodeParams_st.kernel' in found_struct}} - kernel : CUDA_KERNEL_NODE_PARAMS_v3 - Kernel node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} - memcpy : CUDA_MEMCPY_NODE_PARAMS - Memcpy node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memset' in found_struct}} - memset : CUDA_MEMSET_NODE_PARAMS_v2 - Memset node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.host' in found_struct}} - host : CUDA_HOST_NODE_PARAMS_v2 - Host node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.graph' in found_struct}} - graph : CUDA_CHILD_GRAPH_NODE_PARAMS - Child graph node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} - eventWait : CUDA_EVENT_WAIT_NODE_PARAMS - Event wait node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} - eventRecord : CUDA_EVENT_RECORD_NODE_PARAMS - Event record node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} - extSemSignal : CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 - External semaphore signal node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} - extSemWait : CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 - External semaphore wait node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.alloc' in found_struct}} - alloc : CUDA_MEM_ALLOC_NODE_PARAMS_v2 - Memory allocation node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.free' in found_struct}} - free : CUDA_MEM_FREE_NODE_PARAMS - Memory free node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.memOp' in found_struct}} - memOp : CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 - MemOp node parameters. - {{endif}} - {{if 'CUgraphNodeParams_st.conditional' in found_struct}} - conditional : CUDA_CONDITIONAL_NODE_PARAMS - Conditional node parameters. + {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} + ptr : anon_struct23 + {{endif}} - {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} - reserved2 : long long - Reserved bytes. Must be zero. + {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} + array : anon_struct24 + {{endif}} Methods @@ -20212,325 +20225,157 @@ cdef class CUgraphNodeParams_st: getPtr() Get memory address of class instance """ - def __cinit__(self, void_ptr _ptr = 0): - if _ptr == 0: - self._val_ptr = calloc(1, sizeof(cydriver.CUgraphNodeParams_st)) - self._pvt_ptr = self._val_ptr - else: - self._pvt_ptr = _ptr - def __init__(self, void_ptr _ptr = 0): + def __cinit__(self, void_ptr _ptr): + self._pvt_ptr = _ptr + + def __init__(self, void_ptr _ptr): pass - {{if 'CUgraphNodeParams_st.kernel' in found_struct}} - self._kernel = CUDA_KERNEL_NODE_PARAMS_v3(_ptr=&self._pvt_ptr[0].kernel) - {{endif}} - {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} - self._memcpy = CUDA_MEMCPY_NODE_PARAMS(_ptr=&self._pvt_ptr[0].memcpy) - {{endif}} - {{if 'CUgraphNodeParams_st.memset' in found_struct}} - self._memset = CUDA_MEMSET_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].memset) - {{endif}} - {{if 'CUgraphNodeParams_st.host' in found_struct}} - self._host = CUDA_HOST_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].host) - {{endif}} - {{if 'CUgraphNodeParams_st.graph' in found_struct}} - self._graph = CUDA_CHILD_GRAPH_NODE_PARAMS(_ptr=&self._pvt_ptr[0].graph) - {{endif}} - {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} - self._eventWait = CUDA_EVENT_WAIT_NODE_PARAMS(_ptr=&self._pvt_ptr[0].eventWait) - {{endif}} - {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} - self._eventRecord = CUDA_EVENT_RECORD_NODE_PARAMS(_ptr=&self._pvt_ptr[0].eventRecord) - {{endif}} - {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} - self._extSemSignal = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].extSemSignal) - {{endif}} - {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} - self._extSemWait = CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].extSemWait) - {{endif}} - {{if 'CUgraphNodeParams_st.alloc' in found_struct}} - self._alloc = CUDA_MEM_ALLOC_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].alloc) - {{endif}} - {{if 'CUgraphNodeParams_st.free' in found_struct}} - self._free = CUDA_MEM_FREE_NODE_PARAMS(_ptr=&self._pvt_ptr[0].free) - {{endif}} - {{if 'CUgraphNodeParams_st.memOp' in found_struct}} - self._memOp = CUDA_BATCH_MEM_OP_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].memOp) + {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} + self._ptr = anon_struct23(_ptr=self._pvt_ptr) {{endif}} - {{if 'CUgraphNodeParams_st.conditional' in found_struct}} - self._conditional = CUDA_CONDITIONAL_NODE_PARAMS(_ptr=&self._pvt_ptr[0].conditional) + {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} + self._array = anon_struct24(_ptr=self._pvt_ptr) {{endif}} def __dealloc__(self): - if self._val_ptr is not NULL: - free(self._val_ptr) + pass def getPtr(self): - return self._pvt_ptr + return &self._pvt_ptr[0].op def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUgraphNodeParams_st.type' in found_struct}} - try: - str_list += ['type : ' + str(self.type)] - except ValueError: - str_list += ['type : '] - {{endif}} - {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} - try: - str_list += ['reserved0 : ' + str(self.reserved0)] - except ValueError: - str_list += ['reserved0 : '] - {{endif}} - {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} - try: - str_list += ['reserved1 : ' + str(self.reserved1)] - except ValueError: - str_list += ['reserved1 : '] - {{endif}} - {{if 'CUgraphNodeParams_st.kernel' in found_struct}} - try: - str_list += ['kernel :\n' + '\n'.join([' ' + line for line in str(self.kernel).splitlines()])] - except ValueError: - str_list += ['kernel : '] - {{endif}} - {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} - try: - str_list += ['memcpy :\n' + '\n'.join([' ' + line for line in str(self.memcpy).splitlines()])] - except ValueError: - str_list += ['memcpy : '] - {{endif}} - {{if 'CUgraphNodeParams_st.memset' in found_struct}} - try: - str_list += ['memset :\n' + '\n'.join([' ' + line for line in str(self.memset).splitlines()])] - except ValueError: - str_list += ['memset : '] - {{endif}} - {{if 'CUgraphNodeParams_st.host' in found_struct}} - try: - str_list += ['host :\n' + '\n'.join([' ' + line for line in str(self.host).splitlines()])] - except ValueError: - str_list += ['host : '] - {{endif}} - {{if 'CUgraphNodeParams_st.graph' in found_struct}} - try: - str_list += ['graph :\n' + '\n'.join([' ' + line for line in str(self.graph).splitlines()])] - except ValueError: - str_list += ['graph : '] - {{endif}} - {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} - try: - str_list += ['eventWait :\n' + '\n'.join([' ' + line for line in str(self.eventWait).splitlines()])] - except ValueError: - str_list += ['eventWait : '] - {{endif}} - {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} - try: - str_list += ['eventRecord :\n' + '\n'.join([' ' + line for line in str(self.eventRecord).splitlines()])] - except ValueError: - str_list += ['eventRecord : '] - {{endif}} - {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} - try: - str_list += ['extSemSignal :\n' + '\n'.join([' ' + line for line in str(self.extSemSignal).splitlines()])] - except ValueError: - str_list += ['extSemSignal : '] - {{endif}} - {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} - try: - str_list += ['extSemWait :\n' + '\n'.join([' ' + line for line in str(self.extSemWait).splitlines()])] - except ValueError: - str_list += ['extSemWait : '] - {{endif}} - {{if 'CUgraphNodeParams_st.alloc' in found_struct}} - try: - str_list += ['alloc :\n' + '\n'.join([' ' + line for line in str(self.alloc).splitlines()])] - except ValueError: - str_list += ['alloc : '] - {{endif}} - {{if 'CUgraphNodeParams_st.free' in found_struct}} - try: - str_list += ['free :\n' + '\n'.join([' ' + line for line in str(self.free).splitlines()])] - except ValueError: - str_list += ['free : '] - {{endif}} - {{if 'CUgraphNodeParams_st.memOp' in found_struct}} - try: - str_list += ['memOp :\n' + '\n'.join([' ' + line for line in str(self.memOp).splitlines()])] - except ValueError: - str_list += ['memOp : '] - {{endif}} - {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} try: - str_list += ['conditional :\n' + '\n'.join([' ' + line for line in str(self.conditional).splitlines()])] + str_list += ['ptr :\n' + '\n'.join([' ' + line for line in str(self.ptr).splitlines()])] except ValueError: - str_list += ['conditional : '] + str_list += ['ptr : '] {{endif}} - {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} try: - str_list += ['reserved2 : ' + str(self.reserved2)] + str_list += ['array :\n' + '\n'.join([' ' + line for line in str(self.array).splitlines()])] except ValueError: - str_list += ['reserved2 : '] + str_list += ['array : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUgraphNodeParams_st.type' in found_struct}} - @property - def type(self): - if self._pvt_ptr[0].type not in _dict_CUgraphNodeType: - return None - return _dict_CUgraphNodeType[self._pvt_ptr[0].type] - @type.setter - def type(self, type not None : CUgraphNodeType): - self._pvt_ptr[0].type = type.value - {{endif}} - {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} - @property - def reserved0(self): - return self._pvt_ptr[0].reserved0 - @reserved0.setter - def reserved0(self, reserved0): - self._pvt_ptr[0].reserved0 = reserved0 - {{endif}} - {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} - @property - def reserved1(self): - return self._pvt_ptr[0].reserved1 - @reserved1.setter - def reserved1(self, reserved1): - self._pvt_ptr[0].reserved1 = reserved1 - {{endif}} - {{if 'CUgraphNodeParams_st.kernel' in found_struct}} - @property - def kernel(self): - return self._kernel - @kernel.setter - def kernel(self, kernel not None : CUDA_KERNEL_NODE_PARAMS_v3): - string.memcpy(&self._pvt_ptr[0].kernel, kernel.getPtr(), sizeof(self._pvt_ptr[0].kernel)) - {{endif}} - {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} - @property - def memcpy(self): - return self._memcpy - @memcpy.setter - def memcpy(self, memcpy not None : CUDA_MEMCPY_NODE_PARAMS): - string.memcpy(&self._pvt_ptr[0].memcpy, memcpy.getPtr(), sizeof(self._pvt_ptr[0].memcpy)) - {{endif}} - {{if 'CUgraphNodeParams_st.memset' in found_struct}} - @property - def memset(self): - return self._memset - @memset.setter - def memset(self, memset not None : CUDA_MEMSET_NODE_PARAMS_v2): - string.memcpy(&self._pvt_ptr[0].memset, memset.getPtr(), sizeof(self._pvt_ptr[0].memset)) - {{endif}} - {{if 'CUgraphNodeParams_st.host' in found_struct}} - @property - def host(self): - return self._host - @host.setter - def host(self, host not None : CUDA_HOST_NODE_PARAMS_v2): - string.memcpy(&self._pvt_ptr[0].host, host.getPtr(), sizeof(self._pvt_ptr[0].host)) - {{endif}} - {{if 'CUgraphNodeParams_st.graph' in found_struct}} - @property - def graph(self): - return self._graph - @graph.setter - def graph(self, graph not None : CUDA_CHILD_GRAPH_NODE_PARAMS): - string.memcpy(&self._pvt_ptr[0].graph, graph.getPtr(), sizeof(self._pvt_ptr[0].graph)) - {{endif}} - {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} - @property - def eventWait(self): - return self._eventWait - @eventWait.setter - def eventWait(self, eventWait not None : CUDA_EVENT_WAIT_NODE_PARAMS): - string.memcpy(&self._pvt_ptr[0].eventWait, eventWait.getPtr(), sizeof(self._pvt_ptr[0].eventWait)) - {{endif}} - {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} - @property - def eventRecord(self): - return self._eventRecord - @eventRecord.setter - def eventRecord(self, eventRecord not None : CUDA_EVENT_RECORD_NODE_PARAMS): - string.memcpy(&self._pvt_ptr[0].eventRecord, eventRecord.getPtr(), sizeof(self._pvt_ptr[0].eventRecord)) - {{endif}} - {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} - @property - def extSemSignal(self): - return self._extSemSignal - @extSemSignal.setter - def extSemSignal(self, extSemSignal not None : CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2): - string.memcpy(&self._pvt_ptr[0].extSemSignal, extSemSignal.getPtr(), sizeof(self._pvt_ptr[0].extSemSignal)) - {{endif}} - {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} @property - def extSemWait(self): - return self._extSemWait - @extSemWait.setter - def extSemWait(self, extSemWait not None : CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2): - string.memcpy(&self._pvt_ptr[0].extSemWait, extSemWait.getPtr(), sizeof(self._pvt_ptr[0].extSemWait)) + def ptr(self): + return self._ptr + @ptr.setter + def ptr(self, ptr not None : anon_struct23): + string.memcpy(&self._pvt_ptr[0].op.ptr, ptr.getPtr(), sizeof(self._pvt_ptr[0].op.ptr)) {{endif}} - {{if 'CUgraphNodeParams_st.alloc' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} @property - def alloc(self): - return self._alloc - @alloc.setter - def alloc(self, alloc not None : CUDA_MEM_ALLOC_NODE_PARAMS_v2): - string.memcpy(&self._pvt_ptr[0].alloc, alloc.getPtr(), sizeof(self._pvt_ptr[0].alloc)) + def array(self): + return self._array + @array.setter + def array(self, array not None : anon_struct24): + string.memcpy(&self._pvt_ptr[0].op.array, array.getPtr(), sizeof(self._pvt_ptr[0].op.array)) {{endif}} - {{if 'CUgraphNodeParams_st.free' in found_struct}} - @property - def free(self): - return self._free - @free.setter - def free(self, free not None : CUDA_MEM_FREE_NODE_PARAMS): - string.memcpy(&self._pvt_ptr[0].free, free.getPtr(), sizeof(self._pvt_ptr[0].free)) +{{endif}} +{{if 'CUmemcpy3DOperand_st' in found_struct}} + +cdef class CUmemcpy3DOperand_st: + """ + Struct representing an operand for copy with cuMemcpy3DBatchAsync + + Attributes + ---------- + {{if 'CUmemcpy3DOperand_st.type' in found_struct}} + type : CUmemcpy3DOperandType + {{endif}} - {{if 'CUgraphNodeParams_st.memOp' in found_struct}} - @property - def memOp(self): - return self._memOp - @memOp.setter - def memOp(self, memOp not None : CUDA_BATCH_MEM_OP_NODE_PARAMS_v2): - string.memcpy(&self._pvt_ptr[0].memOp, memOp.getPtr(), sizeof(self._pvt_ptr[0].memOp)) + {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + op : anon_union12 + {{endif}} - {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + + Methods + ------- + getPtr() + Get memory address of class instance + """ + def __cinit__(self, void_ptr _ptr = 0): + if _ptr == 0: + self._val_ptr = calloc(1, sizeof(cydriver.CUmemcpy3DOperand_st)) + self._pvt_ptr = self._val_ptr + else: + self._pvt_ptr = _ptr + def __init__(self, void_ptr _ptr = 0): + pass + {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + self._op = anon_union12(_ptr=self._pvt_ptr) + {{endif}} + def __dealloc__(self): + if self._val_ptr is not NULL: + free(self._val_ptr) + def getPtr(self): + return self._pvt_ptr + def __repr__(self): + if self._pvt_ptr is not NULL: + str_list = [] + {{if 'CUmemcpy3DOperand_st.type' in found_struct}} + try: + str_list += ['type : ' + str(self.type)] + except ValueError: + str_list += ['type : '] + {{endif}} + {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + try: + str_list += ['op :\n' + '\n'.join([' ' + line for line in str(self.op).splitlines()])] + except ValueError: + str_list += ['op : '] + {{endif}} + return '\n'.join(str_list) + else: + return '' + {{if 'CUmemcpy3DOperand_st.type' in found_struct}} @property - def conditional(self): - return self._conditional - @conditional.setter - def conditional(self, conditional not None : CUDA_CONDITIONAL_NODE_PARAMS): - string.memcpy(&self._pvt_ptr[0].conditional, conditional.getPtr(), sizeof(self._pvt_ptr[0].conditional)) + def type(self): + if self._pvt_ptr[0].type not in _dict_CUmemcpy3DOperandType: + return None + return _dict_CUmemcpy3DOperandType[self._pvt_ptr[0].type] + @type.setter + def type(self, type not None : CUmemcpy3DOperandType): + self._pvt_ptr[0].type = type.value {{endif}} - {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} + {{if 'CUmemcpy3DOperand_st.op' in found_struct}} @property - def reserved2(self): - return self._pvt_ptr[0].reserved2 - @reserved2.setter - def reserved2(self, long long reserved2): - self._pvt_ptr[0].reserved2 = reserved2 + def op(self): + return self._op + @op.setter + def op(self, op not None : anon_union12): + string.memcpy(&self._pvt_ptr[0].op, op.getPtr(), sizeof(self._pvt_ptr[0].op)) {{endif}} {{endif}} -{{if 'CUcheckpointLockArgs_st' in found_struct}} +{{if 'CUDA_MEMCPY3D_BATCH_OP_st' in found_struct}} -cdef class CUcheckpointLockArgs_st: +cdef class CUDA_MEMCPY3D_BATCH_OP_st: """ - CUDA checkpoint optional lock arguments - Attributes ---------- - {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} - timeoutMs : unsigned int - Timeout in milliseconds to attempt to lock the process, 0 indicates - no timeout + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} + src : CUmemcpy3DOperand + Source memcpy operand. {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} - reserved0 : unsigned int - Reserved for future use, must be zero + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} + dst : CUmemcpy3DOperand + Destination memcpy operand. {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} - reserved1 : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} + extent : CUextent3D + Extents of the memcpy between src and dst. The width, height and + depth components must not be 0. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} + srcAccessOrder : CUmemcpySrcAccessOrder + Source access ordering to be observed for copy from src to dst. + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} + flags : unsigned int + Additional flags for copies with this attribute. See CUmemcpyFlags {{endif}} Methods @@ -20542,9 +20387,18 @@ cdef class CUcheckpointLockArgs_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} + self._src = CUmemcpy3DOperand(_ptr=&self._pvt_ptr[0].src) + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} + self._dst = CUmemcpy3DOperand(_ptr=&self._pvt_ptr[0].dst) + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} + self._extent = CUextent3D(_ptr=&self._pvt_ptr[0].extent) + {{endif}} def __dealloc__(self): pass def getPtr(self): @@ -20552,64 +20406,113 @@ cdef class CUcheckpointLockArgs_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} try: - str_list += ['timeoutMs : ' + str(self.timeoutMs)] + str_list += ['src :\n' + '\n'.join([' ' + line for line in str(self.src).splitlines()])] except ValueError: - str_list += ['timeoutMs : '] + str_list += ['src : '] {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} try: - str_list += ['reserved0 : ' + str(self.reserved0)] + str_list += ['dst :\n' + '\n'.join([' ' + line for line in str(self.dst).splitlines()])] except ValueError: - str_list += ['reserved0 : '] + str_list += ['dst : '] {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} try: - str_list += ['reserved1 : ' + str(self.reserved1)] + str_list += ['extent :\n' + '\n'.join([' ' + line for line in str(self.extent).splitlines()])] except ValueError: - str_list += ['reserved1 : '] + str_list += ['extent : '] + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} + try: + str_list += ['srcAccessOrder : ' + str(self.srcAccessOrder)] + except ValueError: + str_list += ['srcAccessOrder : '] + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} + try: + str_list += ['flags : ' + str(self.flags)] + except ValueError: + str_list += ['flags : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} @property - def timeoutMs(self): - return self._pvt_ptr[0].timeoutMs - @timeoutMs.setter - def timeoutMs(self, unsigned int timeoutMs): - self._pvt_ptr[0].timeoutMs = timeoutMs + def src(self): + return self._src + @src.setter + def src(self, src not None : CUmemcpy3DOperand): + string.memcpy(&self._pvt_ptr[0].src, src.getPtr(), sizeof(self._pvt_ptr[0].src)) {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} @property - def reserved0(self): - return self._pvt_ptr[0].reserved0 - @reserved0.setter - def reserved0(self, unsigned int reserved0): - self._pvt_ptr[0].reserved0 = reserved0 + def dst(self): + return self._dst + @dst.setter + def dst(self, dst not None : CUmemcpy3DOperand): + string.memcpy(&self._pvt_ptr[0].dst, dst.getPtr(), sizeof(self._pvt_ptr[0].dst)) {{endif}} - {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} @property - def reserved1(self): - return [cuuint64_t(init_value=_reserved1) for _reserved1 in self._pvt_ptr[0].reserved1] - @reserved1.setter - def reserved1(self, reserved1): - self._pvt_ptr[0].reserved1 = reserved1 - + def extent(self): + return self._extent + @extent.setter + def extent(self, extent not None : CUextent3D): + string.memcpy(&self._pvt_ptr[0].extent, extent.getPtr(), sizeof(self._pvt_ptr[0].extent)) + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} + @property + def srcAccessOrder(self): + if self._pvt_ptr[0].srcAccessOrder not in _dict_CUmemcpySrcAccessOrder: + return None + return _dict_CUmemcpySrcAccessOrder[self._pvt_ptr[0].srcAccessOrder] + @srcAccessOrder.setter + def srcAccessOrder(self, srcAccessOrder not None : CUmemcpySrcAccessOrder): + self._pvt_ptr[0].srcAccessOrder = srcAccessOrder.value + {{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} + @property + def flags(self): + return self._pvt_ptr[0].flags + @flags.setter + def flags(self, unsigned int flags): + self._pvt_ptr[0].flags = flags {{endif}} {{endif}} -{{if 'CUcheckpointCheckpointArgs_st' in found_struct}} +{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st' in found_struct}} -cdef class CUcheckpointCheckpointArgs_st: +cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v1_st: """ - CUDA checkpoint optional checkpoint arguments + Memory allocation node parameters Attributes ---------- - {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} + poolProps : CUmemPoolProps + in: location where the allocation should reside (specified in + ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is + not supported. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + accessDescs : CUmemAccessDesc + in: array of memory access descriptors. Used to describe peer GPU + access + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} + accessDescCount : size_t + in: number of memory access descriptors. Must not exceed the number + of GPUs. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} + bytesize : size_t + in: size in bytes of the requested allocation + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + dptr : CUdeviceptr + out: address of the allocation returned by CUDA {{endif}} Methods @@ -20621,46 +20524,156 @@ cdef class CUcheckpointCheckpointArgs_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} + self._poolProps = CUmemPoolProps(_ptr=&self._pvt_ptr[0].poolProps) + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + self._dptr = CUdeviceptr(_ptr=&self._pvt_ptr[0].dptr) + {{endif}} def __dealloc__(self): pass + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + if self._accessDescs is not NULL: + free(self._accessDescs) + {{endif}} def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} try: - str_list += ['reserved : ' + str(self.reserved)] + str_list += ['poolProps :\n' + '\n'.join([' ' + line for line in str(self.poolProps).splitlines()])] except ValueError: - str_list += ['reserved : '] + str_list += ['poolProps : '] + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + try: + str_list += ['accessDescs : ' + str(self.accessDescs)] + except ValueError: + str_list += ['accessDescs : '] + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} + try: + str_list += ['accessDescCount : ' + str(self.accessDescCount)] + except ValueError: + str_list += ['accessDescCount : '] + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} + try: + str_list += ['bytesize : ' + str(self.bytesize)] + except ValueError: + str_list += ['bytesize : '] + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + try: + str_list += ['dptr : ' + str(self.dptr)] + except ValueError: + str_list += ['dptr : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.poolProps' in found_struct}} @property - def reserved(self): - return [cuuint64_t(init_value=_reserved) for _reserved in self._pvt_ptr[0].reserved] - @reserved.setter - def reserved(self, reserved): - self._pvt_ptr[0].reserved = reserved + def poolProps(self): + return self._poolProps + @poolProps.setter + def poolProps(self, poolProps not None : CUmemPoolProps): + string.memcpy(&self._pvt_ptr[0].poolProps, poolProps.getPtr(), sizeof(self._pvt_ptr[0].poolProps)) + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescs' in found_struct}} + @property + def accessDescs(self): + arrs = [self._pvt_ptr[0].accessDescs + x*sizeof(cydriver.CUmemAccessDesc) for x in range(self._accessDescs_length)] + return [CUmemAccessDesc(_ptr=arr) for arr in arrs] + @accessDescs.setter + def accessDescs(self, val): + if len(val) == 0: + free(self._accessDescs) + self._accessDescs_length = 0 + self._pvt_ptr[0].accessDescs = NULL + else: + if self._accessDescs_length != len(val): + free(self._accessDescs) + self._accessDescs = calloc(len(val), sizeof(cydriver.CUmemAccessDesc)) + if self._accessDescs is NULL: + raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUmemAccessDesc))) + self._accessDescs_length = len(val) + self._pvt_ptr[0].accessDescs = self._accessDescs + for idx in range(len(val)): + string.memcpy(&self._accessDescs[idx], (val[idx])._pvt_ptr, sizeof(cydriver.CUmemAccessDesc)) + + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.accessDescCount' in found_struct}} + @property + def accessDescCount(self): + return self._pvt_ptr[0].accessDescCount + @accessDescCount.setter + def accessDescCount(self, size_t accessDescCount): + self._pvt_ptr[0].accessDescCount = accessDescCount + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.bytesize' in found_struct}} + @property + def bytesize(self): + return self._pvt_ptr[0].bytesize + @bytesize.setter + def bytesize(self, size_t bytesize): + self._pvt_ptr[0].bytesize = bytesize + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st.dptr' in found_struct}} + @property + def dptr(self): + return self._dptr + @dptr.setter + def dptr(self, dptr): + cdef cydriver.CUdeviceptr cydptr + if dptr is None: + cydptr = 0 + elif isinstance(dptr, (CUdeviceptr)): + pdptr = int(dptr) + cydptr = pdptr + else: + pdptr = int(CUdeviceptr(dptr)) + cydptr = pdptr + self._dptr._pvt_ptr[0] = cydptr {{endif}} {{endif}} -{{if 'CUcheckpointRestoreArgs_st' in found_struct}} +{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st' in found_struct}} -cdef class CUcheckpointRestoreArgs_st: +cdef class CUDA_MEM_ALLOC_NODE_PARAMS_v2_st: """ - CUDA checkpoint optional restore arguments + Memory allocation node parameters Attributes ---------- - {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} + poolProps : CUmemPoolProps + in: location where the allocation should reside (specified in + ::location). ::handleTypes must be CU_MEM_HANDLE_TYPE_NONE. IPC is + not supported. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} + accessDescs : CUmemAccessDesc + in: array of memory access descriptors. Used to describe peer GPU + access + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} + accessDescCount : size_t + in: number of memory access descriptors. Must not exceed the number + of GPUs. + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} + bytesize : size_t + in: size in bytes of the requested allocation + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + dptr : CUdeviceptr + out: address of the allocation returned by CUDA {{endif}} Methods @@ -20672,46 +20685,136 @@ cdef class CUcheckpointRestoreArgs_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} + self._poolProps = CUmemPoolProps(_ptr=&self._pvt_ptr[0].poolProps) + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + self._dptr = CUdeviceptr(_ptr=&self._pvt_ptr[0].dptr) + {{endif}} def __dealloc__(self): pass + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} + if self._accessDescs is not NULL: + free(self._accessDescs) + {{endif}} def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} try: - str_list += ['reserved : ' + str(self.reserved)] + str_list += ['poolProps :\n' + '\n'.join([' ' + line for line in str(self.poolProps).splitlines()])] except ValueError: - str_list += ['reserved : '] + str_list += ['poolProps : '] + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} + try: + str_list += ['accessDescs : ' + str(self.accessDescs)] + except ValueError: + str_list += ['accessDescs : '] + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} + try: + str_list += ['accessDescCount : ' + str(self.accessDescCount)] + except ValueError: + str_list += ['accessDescCount : '] + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} + try: + str_list += ['bytesize : ' + str(self.bytesize)] + except ValueError: + str_list += ['bytesize : '] + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + try: + str_list += ['dptr : ' + str(self.dptr)] + except ValueError: + str_list += ['dptr : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.poolProps' in found_struct}} @property - def reserved(self): - return [cuuint64_t(init_value=_reserved) for _reserved in self._pvt_ptr[0].reserved] - @reserved.setter - def reserved(self, reserved): - self._pvt_ptr[0].reserved = reserved + def poolProps(self): + return self._poolProps + @poolProps.setter + def poolProps(self, poolProps not None : CUmemPoolProps): + string.memcpy(&self._pvt_ptr[0].poolProps, poolProps.getPtr(), sizeof(self._pvt_ptr[0].poolProps)) + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescs' in found_struct}} + @property + def accessDescs(self): + arrs = [self._pvt_ptr[0].accessDescs + x*sizeof(cydriver.CUmemAccessDesc) for x in range(self._accessDescs_length)] + return [CUmemAccessDesc(_ptr=arr) for arr in arrs] + @accessDescs.setter + def accessDescs(self, val): + if len(val) == 0: + free(self._accessDescs) + self._accessDescs_length = 0 + self._pvt_ptr[0].accessDescs = NULL + else: + if self._accessDescs_length != len(val): + free(self._accessDescs) + self._accessDescs = calloc(len(val), sizeof(cydriver.CUmemAccessDesc)) + if self._accessDescs is NULL: + raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUmemAccessDesc))) + self._accessDescs_length = len(val) + self._pvt_ptr[0].accessDescs = self._accessDescs + for idx in range(len(val)): + string.memcpy(&self._accessDescs[idx], (val[idx])._pvt_ptr, sizeof(cydriver.CUmemAccessDesc)) + + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.accessDescCount' in found_struct}} + @property + def accessDescCount(self): + return self._pvt_ptr[0].accessDescCount + @accessDescCount.setter + def accessDescCount(self, size_t accessDescCount): + self._pvt_ptr[0].accessDescCount = accessDescCount + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.bytesize' in found_struct}} + @property + def bytesize(self): + return self._pvt_ptr[0].bytesize + @bytesize.setter + def bytesize(self, size_t bytesize): + self._pvt_ptr[0].bytesize = bytesize + {{endif}} + {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v2_st.dptr' in found_struct}} + @property + def dptr(self): + return self._dptr + @dptr.setter + def dptr(self, dptr): + cdef cydriver.CUdeviceptr cydptr + if dptr is None: + cydptr = 0 + elif isinstance(dptr, (CUdeviceptr)): + pdptr = int(dptr) + cydptr = pdptr + else: + pdptr = int(CUdeviceptr(dptr)) + cydptr = pdptr + self._dptr._pvt_ptr[0] = cydptr {{endif}} {{endif}} -{{if 'CUcheckpointUnlockArgs_st' in found_struct}} +{{if 'CUDA_MEM_FREE_NODE_PARAMS_st' in found_struct}} -cdef class CUcheckpointUnlockArgs_st: +cdef class CUDA_MEM_FREE_NODE_PARAMS_st: """ - CUDA checkpoint optional unlock arguments + Memory free node parameters Attributes ---------- - {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} - reserved : List[cuuint64_t] - Reserved for future use, must be zeroed + {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} + dptr : CUdeviceptr + in: the pointer to free {{endif}} Methods @@ -20723,9 +20826,12 @@ cdef class CUcheckpointUnlockArgs_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass + {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} + self._dptr = CUdeviceptr(_ptr=&self._pvt_ptr[0].dptr) + {{endif}} def __dealloc__(self): pass def getPtr(self): @@ -20733,52 +20839,53 @@ cdef class CUcheckpointUnlockArgs_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} + {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} try: - str_list += ['reserved : ' + str(self.reserved)] + str_list += ['dptr : ' + str(self.dptr)] except ValueError: - str_list += ['reserved : '] + str_list += ['dptr : '] {{endif}} return '\n'.join(str_list) else: - return '' - {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} - @property - def reserved(self): - return [cuuint64_t(init_value=_reserved) for _reserved in self._pvt_ptr[0].reserved] - @reserved.setter - def reserved(self, reserved): - self._pvt_ptr[0].reserved = reserved + return '' + {{if 'CUDA_MEM_FREE_NODE_PARAMS_st.dptr' in found_struct}} + @property + def dptr(self): + return self._dptr + @dptr.setter + def dptr(self, dptr): + cdef cydriver.CUdeviceptr cydptr + if dptr is None: + cydptr = 0 + elif isinstance(dptr, (CUdeviceptr)): + pdptr = int(dptr) + cydptr = pdptr + else: + pdptr = int(CUdeviceptr(dptr)) + cydptr = pdptr + self._dptr._pvt_ptr[0] = cydptr {{endif}} {{endif}} -{{if 'CUmemcpyAttributes_st' in found_struct}} +{{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st' in found_struct}} -cdef class CUmemcpyAttributes_st: +cdef class CUDA_CHILD_GRAPH_NODE_PARAMS_st: """ - Attributes specific to copies within a batch. For more details on - usage see cuMemcpyBatchAsync. + Child graph node parameters Attributes ---------- - {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} - srcAccessOrder : CUmemcpySrcAccessOrder - Source access ordering to be observed for copies with this - attribute. - {{endif}} - {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} - srcLocHint : CUmemLocation - Hint location for the source operand. Ignored when the pointers are - not managed memory or memory allocated outside CUDA. - {{endif}} - {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} - dstLocHint : CUmemLocation - Hint location for the destination operand. Ignored when the - pointers are not managed memory or memory allocated outside CUDA. + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} + graph : CUgraph + The child graph to clone into the node for node creation, or a + handle to the graph owned by the node for node query. The graph + must not contain conditional nodes. Graphs containing memory + allocation or memory free nodes must set the ownership to be moved + to the parent. {{endif}} - {{if 'CUmemcpyAttributes_st.flags' in found_struct}} - flags : unsigned int - Additional flags for copies with this attribute. See CUmemcpyFlags + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.ownership' in found_struct}} + ownership : CUgraphChildGraphNodeOwnership + The ownership relationship of the child graph node. {{endif}} Methods @@ -20790,14 +20897,11 @@ cdef class CUmemcpyAttributes_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} - self._srcLocHint = CUmemLocation(_ptr=&self._pvt_ptr[0].srcLocHint) - {{endif}} - {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} - self._dstLocHint = CUmemLocation(_ptr=&self._pvt_ptr[0].dstLocHint) + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} + self._graph = CUgraph(_ptr=&self._pvt_ptr[0].graph) {{endif}} def __dealloc__(self): pass @@ -20806,87 +20910,60 @@ cdef class CUmemcpyAttributes_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} - try: - str_list += ['srcAccessOrder : ' + str(self.srcAccessOrder)] - except ValueError: - str_list += ['srcAccessOrder : '] - {{endif}} - {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} - try: - str_list += ['srcLocHint :\n' + '\n'.join([' ' + line for line in str(self.srcLocHint).splitlines()])] - except ValueError: - str_list += ['srcLocHint : '] - {{endif}} - {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} try: - str_list += ['dstLocHint :\n' + '\n'.join([' ' + line for line in str(self.dstLocHint).splitlines()])] + str_list += ['graph : ' + str(self.graph)] except ValueError: - str_list += ['dstLocHint : '] + str_list += ['graph : '] {{endif}} - {{if 'CUmemcpyAttributes_st.flags' in found_struct}} + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.ownership' in found_struct}} try: - str_list += ['flags : ' + str(self.flags)] + str_list += ['ownership : ' + str(self.ownership)] except ValueError: - str_list += ['flags : '] + str_list += ['ownership : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}} - @property - def srcAccessOrder(self): - if self._pvt_ptr[0].srcAccessOrder not in _dict_CUmemcpySrcAccessOrder: - return None - return _dict_CUmemcpySrcAccessOrder[self._pvt_ptr[0].srcAccessOrder] - @srcAccessOrder.setter - def srcAccessOrder(self, srcAccessOrder not None : CUmemcpySrcAccessOrder): - self._pvt_ptr[0].srcAccessOrder = srcAccessOrder.value - {{endif}} - {{if 'CUmemcpyAttributes_st.srcLocHint' in found_struct}} - @property - def srcLocHint(self): - return self._srcLocHint - @srcLocHint.setter - def srcLocHint(self, srcLocHint not None : CUmemLocation): - string.memcpy(&self._pvt_ptr[0].srcLocHint, srcLocHint.getPtr(), sizeof(self._pvt_ptr[0].srcLocHint)) - {{endif}} - {{if 'CUmemcpyAttributes_st.dstLocHint' in found_struct}} + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.graph' in found_struct}} @property - def dstLocHint(self): - return self._dstLocHint - @dstLocHint.setter - def dstLocHint(self, dstLocHint not None : CUmemLocation): - string.memcpy(&self._pvt_ptr[0].dstLocHint, dstLocHint.getPtr(), sizeof(self._pvt_ptr[0].dstLocHint)) + def graph(self): + return self._graph + @graph.setter + def graph(self, graph): + cdef cydriver.CUgraph cygraph + if graph is None: + cygraph = 0 + elif isinstance(graph, (CUgraph,)): + pgraph = int(graph) + cygraph = pgraph + else: + pgraph = int(CUgraph(graph)) + cygraph = pgraph + self._graph._pvt_ptr[0] = cygraph {{endif}} - {{if 'CUmemcpyAttributes_st.flags' in found_struct}} + {{if 'CUDA_CHILD_GRAPH_NODE_PARAMS_st.ownership' in found_struct}} @property - def flags(self): - return self._pvt_ptr[0].flags - @flags.setter - def flags(self, unsigned int flags): - self._pvt_ptr[0].flags = flags + def ownership(self): + if self._pvt_ptr[0].ownership not in _dict_CUgraphChildGraphNodeOwnership: + return None + return _dict_CUgraphChildGraphNodeOwnership[self._pvt_ptr[0].ownership] + @ownership.setter + def ownership(self, ownership not None : CUgraphChildGraphNodeOwnership): + self._pvt_ptr[0].ownership = ownership.value {{endif}} {{endif}} -{{if 'CUoffset3D_st' in found_struct}} +{{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st' in found_struct}} -cdef class CUoffset3D_st: +cdef class CUDA_EVENT_RECORD_NODE_PARAMS_st: """ - Struct representing offset into a CUarray in elements + Event record node parameters Attributes ---------- - {{if 'CUoffset3D_st.x' in found_struct}} - x : size_t - - {{endif}} - {{if 'CUoffset3D_st.y' in found_struct}} - y : size_t - - {{endif}} - {{if 'CUoffset3D_st.z' in found_struct}} - z : size_t - + {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} + event : CUevent + The event to record when the node executes {{endif}} Methods @@ -20898,9 +20975,12 @@ cdef class CUoffset3D_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass + {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} + self._event = CUevent(_ptr=&self._pvt_ptr[0].event) + {{endif}} def __dealloc__(self): pass def getPtr(self): @@ -20908,71 +20988,44 @@ cdef class CUoffset3D_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUoffset3D_st.x' in found_struct}} - try: - str_list += ['x : ' + str(self.x)] - except ValueError: - str_list += ['x : '] - {{endif}} - {{if 'CUoffset3D_st.y' in found_struct}} - try: - str_list += ['y : ' + str(self.y)] - except ValueError: - str_list += ['y : '] - {{endif}} - {{if 'CUoffset3D_st.z' in found_struct}} + {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} try: - str_list += ['z : ' + str(self.z)] + str_list += ['event : ' + str(self.event)] except ValueError: - str_list += ['z : '] + str_list += ['event : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUoffset3D_st.x' in found_struct}} - @property - def x(self): - return self._pvt_ptr[0].x - @x.setter - def x(self, size_t x): - self._pvt_ptr[0].x = x - {{endif}} - {{if 'CUoffset3D_st.y' in found_struct}} - @property - def y(self): - return self._pvt_ptr[0].y - @y.setter - def y(self, size_t y): - self._pvt_ptr[0].y = y - {{endif}} - {{if 'CUoffset3D_st.z' in found_struct}} + {{if 'CUDA_EVENT_RECORD_NODE_PARAMS_st.event' in found_struct}} @property - def z(self): - return self._pvt_ptr[0].z - @z.setter - def z(self, size_t z): - self._pvt_ptr[0].z = z + def event(self): + return self._event + @event.setter + def event(self, event): + cdef cydriver.CUevent cyevent + if event is None: + cyevent = 0 + elif isinstance(event, (CUevent,)): + pevent = int(event) + cyevent = pevent + else: + pevent = int(CUevent(event)) + cyevent = pevent + self._event._pvt_ptr[0] = cyevent {{endif}} {{endif}} -{{if 'CUextent3D_st' in found_struct}} +{{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st' in found_struct}} -cdef class CUextent3D_st: +cdef class CUDA_EVENT_WAIT_NODE_PARAMS_st: """ - Struct representing width/height/depth of a CUarray in elements + Event wait node parameters Attributes ---------- - {{if 'CUextent3D_st.width' in found_struct}} - width : size_t - - {{endif}} - {{if 'CUextent3D_st.height' in found_struct}} - height : size_t - - {{endif}} - {{if 'CUextent3D_st.depth' in found_struct}} - depth : size_t - + {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} + event : CUevent + The event to wait on from the node {{endif}} Methods @@ -20984,9 +21037,12 @@ cdef class CUextent3D_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass + {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} + self._event = CUevent(_ptr=&self._pvt_ptr[0].event) + {{endif}} def __dealloc__(self): pass def getPtr(self): @@ -20994,73 +21050,108 @@ cdef class CUextent3D_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUextent3D_st.width' in found_struct}} - try: - str_list += ['width : ' + str(self.width)] - except ValueError: - str_list += ['width : '] - {{endif}} - {{if 'CUextent3D_st.height' in found_struct}} - try: - str_list += ['height : ' + str(self.height)] - except ValueError: - str_list += ['height : '] - {{endif}} - {{if 'CUextent3D_st.depth' in found_struct}} + {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} try: - str_list += ['depth : ' + str(self.depth)] + str_list += ['event : ' + str(self.event)] except ValueError: - str_list += ['depth : '] + str_list += ['event : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUextent3D_st.width' in found_struct}} - @property - def width(self): - return self._pvt_ptr[0].width - @width.setter - def width(self, size_t width): - self._pvt_ptr[0].width = width - {{endif}} - {{if 'CUextent3D_st.height' in found_struct}} - @property - def height(self): - return self._pvt_ptr[0].height - @height.setter - def height(self, size_t height): - self._pvt_ptr[0].height = height - {{endif}} - {{if 'CUextent3D_st.depth' in found_struct}} + {{if 'CUDA_EVENT_WAIT_NODE_PARAMS_st.event' in found_struct}} @property - def depth(self): - return self._pvt_ptr[0].depth - @depth.setter - def depth(self, size_t depth): - self._pvt_ptr[0].depth = depth + def event(self): + return self._event + @event.setter + def event(self, event): + cdef cydriver.CUevent cyevent + if event is None: + cyevent = 0 + elif isinstance(event, (CUevent,)): + pevent = int(event) + cyevent = pevent + else: + pevent = int(CUevent(event)) + cyevent = pevent + self._event._pvt_ptr[0] = cyevent {{endif}} {{endif}} -{{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} +{{if 'CUgraphNodeParams_st' in found_struct}} -cdef class anon_struct23: +cdef class CUgraphNodeParams_st: """ + Graph node parameters. See cuGraphAddNode. + Attributes ---------- - {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} - ptr : CUdeviceptr - + {{if 'CUgraphNodeParams_st.type' in found_struct}} + type : CUgraphNodeType + Type of the node {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.rowLength' in found_struct}} - rowLength : size_t - + {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} + reserved0 : List[int] + Reserved. Must be zero. {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.layerHeight' in found_struct}} - layerHeight : size_t - + {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} + reserved1 : List[long long] + Padding. Unused bytes must be zero. {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} - locHint : CUmemLocation - + {{if 'CUgraphNodeParams_st.kernel' in found_struct}} + kernel : CUDA_KERNEL_NODE_PARAMS_v3 + Kernel node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} + memcpy : CUDA_MEMCPY_NODE_PARAMS + Memcpy node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memset' in found_struct}} + memset : CUDA_MEMSET_NODE_PARAMS_v2 + Memset node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.host' in found_struct}} + host : CUDA_HOST_NODE_PARAMS_v2 + Host node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.graph' in found_struct}} + graph : CUDA_CHILD_GRAPH_NODE_PARAMS + Child graph node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} + eventWait : CUDA_EVENT_WAIT_NODE_PARAMS + Event wait node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} + eventRecord : CUDA_EVENT_RECORD_NODE_PARAMS + Event record node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} + extSemSignal : CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 + External semaphore signal node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} + extSemWait : CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 + External semaphore wait node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.alloc' in found_struct}} + alloc : CUDA_MEM_ALLOC_NODE_PARAMS_v2 + Memory allocation node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.free' in found_struct}} + free : CUDA_MEM_FREE_NODE_PARAMS + Memory free node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.memOp' in found_struct}} + memOp : CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 + MemOp node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + conditional : CUDA_CONDITIONAL_NODE_PARAMS + Conditional node parameters. + {{endif}} + {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} + reserved2 : long long + Reserved bytes. Must be zero. {{endif}} Methods @@ -21068,107 +21159,325 @@ cdef class anon_struct23: getPtr() Get memory address of class instance """ - def __cinit__(self, void_ptr _ptr): - self._pvt_ptr = _ptr - - def __init__(self, void_ptr _ptr): + def __cinit__(self, void_ptr _ptr = 0): + if _ptr == 0: + self._val_ptr = calloc(1, sizeof(cydriver.CUgraphNodeParams_st)) + self._pvt_ptr = self._val_ptr + else: + self._pvt_ptr = _ptr + def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} - self._ptr = CUdeviceptr(_ptr=&self._pvt_ptr[0].op.ptr.ptr) + {{if 'CUgraphNodeParams_st.kernel' in found_struct}} + self._kernel = CUDA_KERNEL_NODE_PARAMS_v3(_ptr=&self._pvt_ptr[0].kernel) {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} - self._locHint = CUmemLocation(_ptr=&self._pvt_ptr[0].op.ptr.locHint) + {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} + self._memcpy = CUDA_MEMCPY_NODE_PARAMS(_ptr=&self._pvt_ptr[0].memcpy) + {{endif}} + {{if 'CUgraphNodeParams_st.memset' in found_struct}} + self._memset = CUDA_MEMSET_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].memset) + {{endif}} + {{if 'CUgraphNodeParams_st.host' in found_struct}} + self._host = CUDA_HOST_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].host) + {{endif}} + {{if 'CUgraphNodeParams_st.graph' in found_struct}} + self._graph = CUDA_CHILD_GRAPH_NODE_PARAMS(_ptr=&self._pvt_ptr[0].graph) + {{endif}} + {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} + self._eventWait = CUDA_EVENT_WAIT_NODE_PARAMS(_ptr=&self._pvt_ptr[0].eventWait) + {{endif}} + {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} + self._eventRecord = CUDA_EVENT_RECORD_NODE_PARAMS(_ptr=&self._pvt_ptr[0].eventRecord) + {{endif}} + {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} + self._extSemSignal = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].extSemSignal) + {{endif}} + {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} + self._extSemWait = CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].extSemWait) + {{endif}} + {{if 'CUgraphNodeParams_st.alloc' in found_struct}} + self._alloc = CUDA_MEM_ALLOC_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].alloc) + {{endif}} + {{if 'CUgraphNodeParams_st.free' in found_struct}} + self._free = CUDA_MEM_FREE_NODE_PARAMS(_ptr=&self._pvt_ptr[0].free) + {{endif}} + {{if 'CUgraphNodeParams_st.memOp' in found_struct}} + self._memOp = CUDA_BATCH_MEM_OP_NODE_PARAMS_v2(_ptr=&self._pvt_ptr[0].memOp) + {{endif}} + {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + self._conditional = CUDA_CONDITIONAL_NODE_PARAMS(_ptr=&self._pvt_ptr[0].conditional) {{endif}} def __dealloc__(self): - pass + if self._val_ptr is not NULL: + free(self._val_ptr) def getPtr(self): - return &self._pvt_ptr[0].op.ptr + return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} + {{if 'CUgraphNodeParams_st.type' in found_struct}} try: - str_list += ['ptr : ' + str(self.ptr)] + str_list += ['type : ' + str(self.type)] except ValueError: - str_list += ['ptr : '] + str_list += ['type : '] {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.rowLength' in found_struct}} + {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} try: - str_list += ['rowLength : ' + str(self.rowLength)] + str_list += ['reserved0 : ' + str(self.reserved0)] except ValueError: - str_list += ['rowLength : '] + str_list += ['reserved0 : '] {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.layerHeight' in found_struct}} + {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} try: - str_list += ['layerHeight : ' + str(self.layerHeight)] + str_list += ['reserved1 : ' + str(self.reserved1)] except ValueError: - str_list += ['layerHeight : '] + str_list += ['reserved1 : '] + {{endif}} + {{if 'CUgraphNodeParams_st.kernel' in found_struct}} + try: + str_list += ['kernel :\n' + '\n'.join([' ' + line for line in str(self.kernel).splitlines()])] + except ValueError: + str_list += ['kernel : '] + {{endif}} + {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} + try: + str_list += ['memcpy :\n' + '\n'.join([' ' + line for line in str(self.memcpy).splitlines()])] + except ValueError: + str_list += ['memcpy : '] + {{endif}} + {{if 'CUgraphNodeParams_st.memset' in found_struct}} + try: + str_list += ['memset :\n' + '\n'.join([' ' + line for line in str(self.memset).splitlines()])] + except ValueError: + str_list += ['memset : '] + {{endif}} + {{if 'CUgraphNodeParams_st.host' in found_struct}} + try: + str_list += ['host :\n' + '\n'.join([' ' + line for line in str(self.host).splitlines()])] + except ValueError: + str_list += ['host : '] + {{endif}} + {{if 'CUgraphNodeParams_st.graph' in found_struct}} + try: + str_list += ['graph :\n' + '\n'.join([' ' + line for line in str(self.graph).splitlines()])] + except ValueError: + str_list += ['graph : '] + {{endif}} + {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} + try: + str_list += ['eventWait :\n' + '\n'.join([' ' + line for line in str(self.eventWait).splitlines()])] + except ValueError: + str_list += ['eventWait : '] + {{endif}} + {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} + try: + str_list += ['eventRecord :\n' + '\n'.join([' ' + line for line in str(self.eventRecord).splitlines()])] + except ValueError: + str_list += ['eventRecord : '] + {{endif}} + {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} + try: + str_list += ['extSemSignal :\n' + '\n'.join([' ' + line for line in str(self.extSemSignal).splitlines()])] + except ValueError: + str_list += ['extSemSignal : '] + {{endif}} + {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} + try: + str_list += ['extSemWait :\n' + '\n'.join([' ' + line for line in str(self.extSemWait).splitlines()])] + except ValueError: + str_list += ['extSemWait : '] + {{endif}} + {{if 'CUgraphNodeParams_st.alloc' in found_struct}} + try: + str_list += ['alloc :\n' + '\n'.join([' ' + line for line in str(self.alloc).splitlines()])] + except ValueError: + str_list += ['alloc : '] + {{endif}} + {{if 'CUgraphNodeParams_st.free' in found_struct}} + try: + str_list += ['free :\n' + '\n'.join([' ' + line for line in str(self.free).splitlines()])] + except ValueError: + str_list += ['free : '] + {{endif}} + {{if 'CUgraphNodeParams_st.memOp' in found_struct}} + try: + str_list += ['memOp :\n' + '\n'.join([' ' + line for line in str(self.memOp).splitlines()])] + except ValueError: + str_list += ['memOp : '] + {{endif}} + {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + try: + str_list += ['conditional :\n' + '\n'.join([' ' + line for line in str(self.conditional).splitlines()])] + except ValueError: + str_list += ['conditional : '] {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} + {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} try: - str_list += ['locHint :\n' + '\n'.join([' ' + line for line in str(self.locHint).splitlines()])] + str_list += ['reserved2 : ' + str(self.reserved2)] except ValueError: - str_list += ['locHint : '] + str_list += ['reserved2 : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUmemcpy3DOperand_st.op.ptr.ptr' in found_struct}} + {{if 'CUgraphNodeParams_st.type' in found_struct}} @property - def ptr(self): - return self._ptr - @ptr.setter - def ptr(self, ptr): - cdef cydriver.CUdeviceptr cyptr - if ptr is None: - cyptr = 0 - elif isinstance(ptr, (CUdeviceptr)): - pptr = int(ptr) - cyptr = pptr - else: - pptr = int(CUdeviceptr(ptr)) - cyptr = pptr - self._ptr._pvt_ptr[0] = cyptr - + def type(self): + if self._pvt_ptr[0].type not in _dict_CUgraphNodeType: + return None + return _dict_CUgraphNodeType[self._pvt_ptr[0].type] + @type.setter + def type(self, type not None : CUgraphNodeType): + self._pvt_ptr[0].type = type.value {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.rowLength' in found_struct}} + {{if 'CUgraphNodeParams_st.reserved0' in found_struct}} @property - def rowLength(self): - return self._pvt_ptr[0].op.ptr.rowLength - @rowLength.setter - def rowLength(self, size_t rowLength): - self._pvt_ptr[0].op.ptr.rowLength = rowLength + def reserved0(self): + return self._pvt_ptr[0].reserved0 + @reserved0.setter + def reserved0(self, reserved0): + self._pvt_ptr[0].reserved0 = reserved0 {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.layerHeight' in found_struct}} + {{if 'CUgraphNodeParams_st.reserved1' in found_struct}} @property - def layerHeight(self): - return self._pvt_ptr[0].op.ptr.layerHeight - @layerHeight.setter - def layerHeight(self, size_t layerHeight): - self._pvt_ptr[0].op.ptr.layerHeight = layerHeight + def reserved1(self): + return self._pvt_ptr[0].reserved1 + @reserved1.setter + def reserved1(self, reserved1): + self._pvt_ptr[0].reserved1 = reserved1 {{endif}} - {{if 'CUmemcpy3DOperand_st.op.ptr.locHint' in found_struct}} + {{if 'CUgraphNodeParams_st.kernel' in found_struct}} @property - def locHint(self): - return self._locHint - @locHint.setter - def locHint(self, locHint not None : CUmemLocation): - string.memcpy(&self._pvt_ptr[0].op.ptr.locHint, locHint.getPtr(), sizeof(self._pvt_ptr[0].op.ptr.locHint)) + def kernel(self): + return self._kernel + @kernel.setter + def kernel(self, kernel not None : CUDA_KERNEL_NODE_PARAMS_v3): + string.memcpy(&self._pvt_ptr[0].kernel, kernel.getPtr(), sizeof(self._pvt_ptr[0].kernel)) + {{endif}} + {{if 'CUgraphNodeParams_st.memcpy' in found_struct}} + @property + def memcpy(self): + return self._memcpy + @memcpy.setter + def memcpy(self, memcpy not None : CUDA_MEMCPY_NODE_PARAMS): + string.memcpy(&self._pvt_ptr[0].memcpy, memcpy.getPtr(), sizeof(self._pvt_ptr[0].memcpy)) + {{endif}} + {{if 'CUgraphNodeParams_st.memset' in found_struct}} + @property + def memset(self): + return self._memset + @memset.setter + def memset(self, memset not None : CUDA_MEMSET_NODE_PARAMS_v2): + string.memcpy(&self._pvt_ptr[0].memset, memset.getPtr(), sizeof(self._pvt_ptr[0].memset)) + {{endif}} + {{if 'CUgraphNodeParams_st.host' in found_struct}} + @property + def host(self): + return self._host + @host.setter + def host(self, host not None : CUDA_HOST_NODE_PARAMS_v2): + string.memcpy(&self._pvt_ptr[0].host, host.getPtr(), sizeof(self._pvt_ptr[0].host)) + {{endif}} + {{if 'CUgraphNodeParams_st.graph' in found_struct}} + @property + def graph(self): + return self._graph + @graph.setter + def graph(self, graph not None : CUDA_CHILD_GRAPH_NODE_PARAMS): + string.memcpy(&self._pvt_ptr[0].graph, graph.getPtr(), sizeof(self._pvt_ptr[0].graph)) + {{endif}} + {{if 'CUgraphNodeParams_st.eventWait' in found_struct}} + @property + def eventWait(self): + return self._eventWait + @eventWait.setter + def eventWait(self, eventWait not None : CUDA_EVENT_WAIT_NODE_PARAMS): + string.memcpy(&self._pvt_ptr[0].eventWait, eventWait.getPtr(), sizeof(self._pvt_ptr[0].eventWait)) + {{endif}} + {{if 'CUgraphNodeParams_st.eventRecord' in found_struct}} + @property + def eventRecord(self): + return self._eventRecord + @eventRecord.setter + def eventRecord(self, eventRecord not None : CUDA_EVENT_RECORD_NODE_PARAMS): + string.memcpy(&self._pvt_ptr[0].eventRecord, eventRecord.getPtr(), sizeof(self._pvt_ptr[0].eventRecord)) + {{endif}} + {{if 'CUgraphNodeParams_st.extSemSignal' in found_struct}} + @property + def extSemSignal(self): + return self._extSemSignal + @extSemSignal.setter + def extSemSignal(self, extSemSignal not None : CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2): + string.memcpy(&self._pvt_ptr[0].extSemSignal, extSemSignal.getPtr(), sizeof(self._pvt_ptr[0].extSemSignal)) + {{endif}} + {{if 'CUgraphNodeParams_st.extSemWait' in found_struct}} + @property + def extSemWait(self): + return self._extSemWait + @extSemWait.setter + def extSemWait(self, extSemWait not None : CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2): + string.memcpy(&self._pvt_ptr[0].extSemWait, extSemWait.getPtr(), sizeof(self._pvt_ptr[0].extSemWait)) + {{endif}} + {{if 'CUgraphNodeParams_st.alloc' in found_struct}} + @property + def alloc(self): + return self._alloc + @alloc.setter + def alloc(self, alloc not None : CUDA_MEM_ALLOC_NODE_PARAMS_v2): + string.memcpy(&self._pvt_ptr[0].alloc, alloc.getPtr(), sizeof(self._pvt_ptr[0].alloc)) + {{endif}} + {{if 'CUgraphNodeParams_st.free' in found_struct}} + @property + def free(self): + return self._free + @free.setter + def free(self, free not None : CUDA_MEM_FREE_NODE_PARAMS): + string.memcpy(&self._pvt_ptr[0].free, free.getPtr(), sizeof(self._pvt_ptr[0].free)) + {{endif}} + {{if 'CUgraphNodeParams_st.memOp' in found_struct}} + @property + def memOp(self): + return self._memOp + @memOp.setter + def memOp(self, memOp not None : CUDA_BATCH_MEM_OP_NODE_PARAMS_v2): + string.memcpy(&self._pvt_ptr[0].memOp, memOp.getPtr(), sizeof(self._pvt_ptr[0].memOp)) + {{endif}} + {{if 'CUgraphNodeParams_st.conditional' in found_struct}} + @property + def conditional(self): + return self._conditional + @conditional.setter + def conditional(self, conditional not None : CUDA_CONDITIONAL_NODE_PARAMS): + string.memcpy(&self._pvt_ptr[0].conditional, conditional.getPtr(), sizeof(self._pvt_ptr[0].conditional)) + {{endif}} + {{if 'CUgraphNodeParams_st.reserved2' in found_struct}} + @property + def reserved2(self): + return self._pvt_ptr[0].reserved2 + @reserved2.setter + def reserved2(self, long long reserved2): + self._pvt_ptr[0].reserved2 = reserved2 {{endif}} {{endif}} -{{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} +{{if 'CUcheckpointLockArgs_st' in found_struct}} -cdef class anon_struct24: +cdef class CUcheckpointLockArgs_st: """ + CUDA checkpoint optional lock arguments + Attributes ---------- - {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} - array : CUarray - + {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} + timeoutMs : unsigned int + Timeout in milliseconds to attempt to lock the process, 0 indicates + no timeout {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} - offset : CUoffset3D - + {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} + reserved0 : unsigned int + Reserved for future use, must be zero + {{endif}} + {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} + reserved1 : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -21176,78 +21485,78 @@ cdef class anon_struct24: getPtr() Get memory address of class instance """ - def __cinit__(self, void_ptr _ptr): - self._pvt_ptr = _ptr - - def __init__(self, void_ptr _ptr): + def __cinit__(self, void_ptr _ptr = 0): + if _ptr == 0: + self._pvt_ptr = &self._pvt_val + else: + self._pvt_ptr = _ptr + def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} - self._array = CUarray(_ptr=&self._pvt_ptr[0].op.array.array) - {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} - self._offset = CUoffset3D(_ptr=&self._pvt_ptr[0].op.array.offset) - {{endif}} def __dealloc__(self): pass def getPtr(self): - return &self._pvt_ptr[0].op.array + return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} + {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} try: - str_list += ['array : ' + str(self.array)] + str_list += ['timeoutMs : ' + str(self.timeoutMs)] except ValueError: - str_list += ['array : '] + str_list += ['timeoutMs : '] {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} + {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} try: - str_list += ['offset :\n' + '\n'.join([' ' + line for line in str(self.offset).splitlines()])] + str_list += ['reserved0 : ' + str(self.reserved0)] except ValueError: - str_list += ['offset : '] + str_list += ['reserved0 : '] + {{endif}} + {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} + try: + str_list += ['reserved1 : ' + str(self.reserved1)] + except ValueError: + str_list += ['reserved1 : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUmemcpy3DOperand_st.op.array.array' in found_struct}} + {{if 'CUcheckpointLockArgs_st.timeoutMs' in found_struct}} @property - def array(self): - return self._array - @array.setter - def array(self, array): - cdef cydriver.CUarray cyarray - if array is None: - cyarray = 0 - elif isinstance(array, (CUarray,)): - parray = int(array) - cyarray = parray - else: - parray = int(CUarray(array)) - cyarray = parray - self._array._pvt_ptr[0] = cyarray + def timeoutMs(self): + return self._pvt_ptr[0].timeoutMs + @timeoutMs.setter + def timeoutMs(self, unsigned int timeoutMs): + self._pvt_ptr[0].timeoutMs = timeoutMs {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array.offset' in found_struct}} + {{if 'CUcheckpointLockArgs_st.reserved0' in found_struct}} @property - def offset(self): - return self._offset - @offset.setter - def offset(self, offset not None : CUoffset3D): - string.memcpy(&self._pvt_ptr[0].op.array.offset, offset.getPtr(), sizeof(self._pvt_ptr[0].op.array.offset)) + def reserved0(self): + return self._pvt_ptr[0].reserved0 + @reserved0.setter + def reserved0(self, unsigned int reserved0): + self._pvt_ptr[0].reserved0 = reserved0 + {{endif}} + {{if 'CUcheckpointLockArgs_st.reserved1' in found_struct}} + @property + def reserved1(self): + return [cuuint64_t(init_value=_reserved1) for _reserved1 in self._pvt_ptr[0].reserved1] + @reserved1.setter + def reserved1(self, reserved1): + self._pvt_ptr[0].reserved1 = reserved1 + {{endif}} {{endif}} -{{if 'CUmemcpy3DOperand_st.op' in found_struct}} +{{if 'CUcheckpointCheckpointArgs_st' in found_struct}} -cdef class anon_union13: +cdef class CUcheckpointCheckpointArgs_st: """ + CUDA checkpoint optional checkpoint arguments + Attributes ---------- - {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} - ptr : anon_struct23 - - {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} - array : anon_struct24 - + {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -21255,71 +21564,50 @@ cdef class anon_union13: getPtr() Get memory address of class instance """ - def __cinit__(self, void_ptr _ptr): - self._pvt_ptr = _ptr - - def __init__(self, void_ptr _ptr): + def __cinit__(self, void_ptr _ptr = 0): + if _ptr == 0: + self._pvt_ptr = &self._pvt_val + else: + self._pvt_ptr = _ptr + def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} - self._ptr = anon_struct23(_ptr=self._pvt_ptr) - {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} - self._array = anon_struct24(_ptr=self._pvt_ptr) - {{endif}} def __dealloc__(self): pass def getPtr(self): - return &self._pvt_ptr[0].op + return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} - try: - str_list += ['ptr :\n' + '\n'.join([' ' + line for line in str(self.ptr).splitlines()])] - except ValueError: - str_list += ['ptr : '] - {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} + {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} try: - str_list += ['array :\n' + '\n'.join([' ' + line for line in str(self.array).splitlines()])] + str_list += ['reserved : ' + str(self.reserved)] except ValueError: - str_list += ['array : '] + str_list += ['reserved : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUmemcpy3DOperand_st.op.ptr' in found_struct}} - @property - def ptr(self): - return self._ptr - @ptr.setter - def ptr(self, ptr not None : anon_struct23): - string.memcpy(&self._pvt_ptr[0].op.ptr, ptr.getPtr(), sizeof(self._pvt_ptr[0].op.ptr)) - {{endif}} - {{if 'CUmemcpy3DOperand_st.op.array' in found_struct}} + {{if 'CUcheckpointCheckpointArgs_st.reserved' in found_struct}} @property - def array(self): - return self._array - @array.setter - def array(self, array not None : anon_struct24): - string.memcpy(&self._pvt_ptr[0].op.array, array.getPtr(), sizeof(self._pvt_ptr[0].op.array)) + def reserved(self): + return [cuuint64_t(init_value=_reserved) for _reserved in self._pvt_ptr[0].reserved] + @reserved.setter + def reserved(self, reserved): + self._pvt_ptr[0].reserved = reserved + {{endif}} {{endif}} -{{if 'CUmemcpy3DOperand_st' in found_struct}} +{{if 'CUcheckpointRestoreArgs_st' in found_struct}} -cdef class CUmemcpy3DOperand_st: +cdef class CUcheckpointRestoreArgs_st: """ - Struct representing an operand for copy with cuMemcpy3DBatchAsync + CUDA checkpoint optional restore arguments Attributes ---------- - {{if 'CUmemcpy3DOperand_st.type' in found_struct}} - type : CUmemcpy3DOperandType - - {{endif}} - {{if 'CUmemcpy3DOperand_st.op' in found_struct}} - op : anon_union13 - + {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -21329,83 +21617,48 @@ cdef class CUmemcpy3DOperand_st: """ def __cinit__(self, void_ptr _ptr = 0): if _ptr == 0: - self._val_ptr = calloc(1, sizeof(cydriver.CUmemcpy3DOperand_st)) - self._pvt_ptr = self._val_ptr + self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUmemcpy3DOperand_st.op' in found_struct}} - self._op = anon_union13(_ptr=self._pvt_ptr) - {{endif}} def __dealloc__(self): - if self._val_ptr is not NULL: - free(self._val_ptr) + pass def getPtr(self): return self._pvt_ptr def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUmemcpy3DOperand_st.type' in found_struct}} - try: - str_list += ['type : ' + str(self.type)] - except ValueError: - str_list += ['type : '] - {{endif}} - {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} try: - str_list += ['op :\n' + '\n'.join([' ' + line for line in str(self.op).splitlines()])] + str_list += ['reserved : ' + str(self.reserved)] except ValueError: - str_list += ['op : '] + str_list += ['reserved : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUmemcpy3DOperand_st.type' in found_struct}} - @property - def type(self): - if self._pvt_ptr[0].type not in _dict_CUmemcpy3DOperandType: - return None - return _dict_CUmemcpy3DOperandType[self._pvt_ptr[0].type] - @type.setter - def type(self, type not None : CUmemcpy3DOperandType): - self._pvt_ptr[0].type = type.value - {{endif}} - {{if 'CUmemcpy3DOperand_st.op' in found_struct}} + {{if 'CUcheckpointRestoreArgs_st.reserved' in found_struct}} @property - def op(self): - return self._op - @op.setter - def op(self, op not None : anon_union13): - string.memcpy(&self._pvt_ptr[0].op, op.getPtr(), sizeof(self._pvt_ptr[0].op)) + def reserved(self): + return [cuuint64_t(init_value=_reserved) for _reserved in self._pvt_ptr[0].reserved] + @reserved.setter + def reserved(self, reserved): + self._pvt_ptr[0].reserved = reserved + {{endif}} {{endif}} -{{if 'CUDA_MEMCPY3D_BATCH_OP_st' in found_struct}} +{{if 'CUcheckpointUnlockArgs_st' in found_struct}} -cdef class CUDA_MEMCPY3D_BATCH_OP_st: +cdef class CUcheckpointUnlockArgs_st: """ + CUDA checkpoint optional unlock arguments + Attributes ---------- - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} - src : CUmemcpy3DOperand - Source memcpy operand. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} - dst : CUmemcpy3DOperand - Destination memcpy operand. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} - extent : CUextent3D - Extents of the memcpy between src and dst. The width, height and - depth components must not be 0. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} - srcAccessOrder : CUmemcpySrcAccessOrder - Source access ordering to be observed for copy from src to dst. - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} - flags : unsigned int - Additional flags for copies with this attribute. See CUmemcpyFlags + {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} + reserved : List[cuuint64_t] + Reserved for future use, must be zeroed {{endif}} Methods @@ -21417,18 +21670,9 @@ cdef class CUDA_MEMCPY3D_BATCH_OP_st: if _ptr == 0: self._pvt_ptr = &self._pvt_val else: - self._pvt_ptr = _ptr + self._pvt_ptr = _ptr def __init__(self, void_ptr _ptr = 0): pass - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} - self._src = CUmemcpy3DOperand(_ptr=&self._pvt_ptr[0].src) - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} - self._dst = CUmemcpy3DOperand(_ptr=&self._pvt_ptr[0].dst) - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} - self._extent = CUextent3D(_ptr=&self._pvt_ptr[0].extent) - {{endif}} def __dealloc__(self): pass def getPtr(self): @@ -21436,80 +21680,23 @@ cdef class CUDA_MEMCPY3D_BATCH_OP_st: def __repr__(self): if self._pvt_ptr is not NULL: str_list = [] - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} - try: - str_list += ['src :\n' + '\n'.join([' ' + line for line in str(self.src).splitlines()])] - except ValueError: - str_list += ['src : '] - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} - try: - str_list += ['dst :\n' + '\n'.join([' ' + line for line in str(self.dst).splitlines()])] - except ValueError: - str_list += ['dst : '] - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} - try: - str_list += ['extent :\n' + '\n'.join([' ' + line for line in str(self.extent).splitlines()])] - except ValueError: - str_list += ['extent : '] - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} - try: - str_list += ['srcAccessOrder : ' + str(self.srcAccessOrder)] - except ValueError: - str_list += ['srcAccessOrder : '] - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} + {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} try: - str_list += ['flags : ' + str(self.flags)] + str_list += ['reserved : ' + str(self.reserved)] except ValueError: - str_list += ['flags : '] + str_list += ['reserved : '] {{endif}} return '\n'.join(str_list) else: return '' - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.src' in found_struct}} - @property - def src(self): - return self._src - @src.setter - def src(self, src not None : CUmemcpy3DOperand): - string.memcpy(&self._pvt_ptr[0].src, src.getPtr(), sizeof(self._pvt_ptr[0].src)) - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.dst' in found_struct}} - @property - def dst(self): - return self._dst - @dst.setter - def dst(self, dst not None : CUmemcpy3DOperand): - string.memcpy(&self._pvt_ptr[0].dst, dst.getPtr(), sizeof(self._pvt_ptr[0].dst)) - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.extent' in found_struct}} - @property - def extent(self): - return self._extent - @extent.setter - def extent(self, extent not None : CUextent3D): - string.memcpy(&self._pvt_ptr[0].extent, extent.getPtr(), sizeof(self._pvt_ptr[0].extent)) - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}} - @property - def srcAccessOrder(self): - if self._pvt_ptr[0].srcAccessOrder not in _dict_CUmemcpySrcAccessOrder: - return None - return _dict_CUmemcpySrcAccessOrder[self._pvt_ptr[0].srcAccessOrder] - @srcAccessOrder.setter - def srcAccessOrder(self, srcAccessOrder not None : CUmemcpySrcAccessOrder): - self._pvt_ptr[0].srcAccessOrder = srcAccessOrder.value - {{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st.flags' in found_struct}} + {{if 'CUcheckpointUnlockArgs_st.reserved' in found_struct}} @property - def flags(self): - return self._pvt_ptr[0].flags - @flags.setter - def flags(self, unsigned int flags): - self._pvt_ptr[0].flags = flags + def reserved(self): + return [cuuint64_t(init_value=_reserved) for _reserved in self._pvt_ptr[0].reserved] + @reserved.setter + def reserved(self, reserved): + self._pvt_ptr[0].reserved = reserved + {{endif}} {{endif}} {{if 'CUmemDecompressParams_st' in found_struct}} @@ -21749,7 +21936,7 @@ cdef class CUdevResource_st: {{endif}} {{if 'CUdevResource_st.sm' in found_struct}} sm : CUdevSmResource - Resource corresponding to CU_DEV_RESOURCE_TYPE_SM ``. type. + Resource corresponding to CU_DEV_RESOURCE_TYPE_SM `typename`. {{endif}} {{if 'CUdevResource_st._oversize' in found_struct}} _oversize : bytes @@ -22350,6 +22537,34 @@ cdef class CUmemGenericAllocationHandle_v1: return self._pvt_ptr {{endif}} +{{if 'CUlogIterator' in found_types}} + +cdef class CUlogIterator: + """ + + Methods + ------- + getPtr() + Get memory address of class instance + + """ + def __cinit__(self, unsigned int init_value = 0, void_ptr _ptr = 0): + if _ptr == 0: + self._pvt_ptr = &self._pvt_val + else: + self._pvt_ptr = _ptr + if init_value: + self._pvt_ptr[0] = init_value + def __dealloc__(self): + pass + def __repr__(self): + return '' + def __int__(self): + return self._pvt_ptr[0] + def getPtr(self): + return self._pvt_ptr +{{endif}} + {{if True}} cdef class GLenum: @@ -22735,7 +22950,8 @@ def cuDeviceGetName(int length, dev): Returns an ASCII string identifying the device `dev` in the NULL- terminated string pointed to by `name`. `length` specifies the maximum - length of the string that may be returned. + length of the string that may be returned. `name` is shortened to the + specified `length`, if `length` is less than the device name Parameters ---------- @@ -23388,6 +23604,15 @@ def cuDeviceGetAttribute(attrib not None : CUdevice_attribute, dev): - :py:obj:`~.CU_DEVICE_ATTRIBUTE_GPU_PCI_SUBSYSTEM_ID`: The combined 16-bit PCI subsystem ID and 16-bit PCI subsystem vendor ID. ID. + - :py:obj:`~.CU_DEVICE_ATTRIBUTE_HOST_NUMA_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED`: + Device supports HOST_NUMA location with the virtual memory management + APIs like :py:obj:`~.cuMemCreate`, :py:obj:`~.cuMemMap` and related + APIs + + - :py:obj:`~.CU_DEVICE_ATTRIBUTE_HOST_NUMA_MEMORY_POOLS_SUPPORTED`: + Device supports HOST_NUMA location with the + :py:obj:`~.cuMemAllocAsync` and :py:obj:`~.cuMemPool` family of APIs + Parameters ---------- attrib : :py:obj:`~.CUdevice_attribute` @@ -24526,9 +24751,13 @@ def cuCtxCreate_v4(ctxCreateParams : Optional[CUctxCreateParams], unsigned int f `sharedData` in `cigParams`. Support for D3D12 graphics client can be determined using :py:obj:`~.cuDeviceGetAttribute()` with :py:obj:`~.CU_DEVICE_ATTRIBUTE_D3D12_CIG_SUPPORTED`. `sharedData` is a - ID3D12CommandQueue handle. Either `execAffinityParams` or `cigParams` - can be set to a non-null value. Setting both to a non-null value will - result in an undefined behavior. + ID3D12CommandQueue handle. Support for Vulkan graphics client can be + determined using :py:obj:`~.cuDeviceGetAttribute()` with + :py:obj:`~.CU_DEVICE_ATTRIBUTE_VULKAN_CIG_SUPPORTED`. `sharedData` is a + Nvidia specific data blob populated by calling + vkGetExternalComputeQueueDataNV(). Either `execAffinityParams` or + `cigParams` can be set to a non-null value. Setting both to a non-null + value will result in an undefined behavior. The three LSBs of the `flags` parameter can be used to control how the OS thread, which owns the CUDA context at the time of an API call, @@ -25468,7 +25697,7 @@ def cuCtxRecordEvent(hCtx, hEvent): Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED` See Also -------- @@ -28279,7 +28508,7 @@ def cuDeviceRegisterAsyncNotification(device, callbackFunc, userData): Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` :py:obj:`~.CUDA_ERROR_INVALID_DEVICE` :py:obj:`~.CUDA_ERROR_INVALID_VALUE` :py:obj:`~.CUDA_ERROR_NOT_PERMITTED` :py:obj:`~.CUDA_ERROR_UNKNOWN` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_UNKNOWN` callback : :py:obj:`~.CUasyncCallbackHandle` A handle representing the registered callback instance @@ -28346,7 +28575,7 @@ def cuDeviceUnregisterAsyncNotification(device, callback): Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` :py:obj:`~.CUDA_ERROR_INVALID_DEVICE` :py:obj:`~.CUDA_ERROR_INVALID_VALUE` :py:obj:`~.CUDA_ERROR_NOT_PERMITTED` :py:obj:`~.CUDA_ERROR_UNKNOWN` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_UNKNOWN` See Also -------- @@ -28481,7 +28710,7 @@ def cuIpcGetEventHandle(event): addressing on Linux and Windows operating systems. IPC functionality on Windows is supported for compatibility purposes but not recommended as it comes with performance cost. Users can test their device for IPC - functionality by calling :py:obj:`~.cuapiDeviceGetAttribute` with + functionality by calling :py:obj:`~.cuDeviceGetAttribute` with :py:obj:`~.CU_DEVICE_ATTRIBUTE_IPC_EVENT_SUPPORTED` Parameters @@ -30623,7 +30852,7 @@ def cuMemcpyBatchAsync(dsts : Optional[Tuple[CUdeviceptr] | List[CUdeviceptr]], Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_DEINITIALIZED` :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED` :py:obj:`~.CUDA_ERROR_INVALID_VALUE` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE` failIdx : int Pointer to a location to return the index of the copy where a failure was encountered. The value will be SIZE_MAX if the error @@ -30798,7 +31027,7 @@ def cuMemcpy3DBatchAsync(size_t numOps, opList : Optional[Tuple[CUDA_MEMCPY3D_BA Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_DEINITIALIZED` :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED` :py:obj:`~.CUDA_ERROR_INVALID_VALUE` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE` failIdx : int Pointer to a location to return the index of the copy where a failure was encountered. The value will be SIZE_MAX if the error @@ -32269,7 +32498,7 @@ def cuMemGetHandleForAddressRange(dptr, size_t size, handleType not None : CUmem Returns ------- CUresult - CUDA_SUCCESS CUDA_ERROR_INVALID_VALUE CUDA_ERROR_NOT_SUPPORTED + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` handle : Any Pointer to the location where the returned handle will be stored. """ @@ -32385,7 +32614,10 @@ def cuMemAddressReserve(size_t size, size_t alignment, addr, unsigned long long the starting address of the range in `ptr`. This API requires a system that supports UVA. The size and address parameters must be a multiple of the host page size and the alignment must be a power of two or zero - for default alignment. + for default alignment. If `addr` is 0, then the driver chooses the + address at which to place the start of the reservation whereas when it + is non-zero then the driver treats it as a hint about where to place + the reservation. Parameters ---------- @@ -32394,7 +32626,7 @@ def cuMemAddressReserve(size_t size, size_t alignment, addr, unsigned long long alignment : size_t Alignment of the reserved virtual address range requested addr : :py:obj:`~.CUdeviceptr` - Fixed starting address range requested + Hint address for the start of the address range flags : unsigned long long Currently unused, must be zero @@ -32612,6 +32844,12 @@ def cuMemMap(ptr, size_t size, size_t offset, handle, unsigned long long flags): :py:obj:`~.cuMulticastGetGranularity` with the flag :py:obj:`~.CU_MULTICAST_RECOMMENDED_GRANULARITY`. + When `handle` represents a multicast object, this call may return + CUDA_ERROR_ILLEGAL_STATE if the system configuration is in an illegal + state. In such cases, to continue using multicast, verify that the + system configuration is in a valid state and all required driver + daemons are running properly. + Please note calling :py:obj:`~.cuMemMap` does not make the address accessible, the caller needs to update accessibility of a contiguous mapped VA range by calling :py:obj:`~.cuMemSetAccess`. @@ -32640,7 +32878,7 @@ def cuMemMap(ptr, size_t size, size_t offset, handle, unsigned long long flags): Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`, :py:obj:`~.CUDA_ERROR_ILLEGAL_STATE` See Also -------- @@ -33671,7 +33909,7 @@ def cuMemPoolCreate(poolProps : Optional[CUmemPoolProps]): Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED` :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` pool : :py:obj:`~.CUmemoryPool` None @@ -34137,6 +34375,11 @@ def cuMulticastBindMem(mcHandle, size_t mcOffset, memHandle, size_t memOffset, s call may also return CUDA_ERROR_SYSTEM_NOT_READY if the necessary system software is not initialized or running. + This call may return CUDA_ERROR_ILLEGAL_STATE if the system + configuration is in an illegal state. In such cases, to continue using + multicast, verify that the system configuration is in a valid state and + all required driver daemons are running properly. + Parameters ---------- mcHandle : :py:obj:`~.CUmemGenericAllocationHandle` @@ -34155,7 +34398,7 @@ def cuMulticastBindMem(mcHandle, size_t mcOffset, memHandle, size_t memOffset, s Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`, :py:obj:`~.CUDA_ERROR_SYSTEM_NOT_READY` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`, :py:obj:`~.CUDA_ERROR_SYSTEM_NOT_READY`, :py:obj:`~.CUDA_ERROR_ILLEGAL_STATE` See Also -------- @@ -34209,6 +34452,11 @@ def cuMulticastBindAddr(mcHandle, size_t mcOffset, memptr, size_t size, unsigned call may also return CUDA_ERROR_SYSTEM_NOT_READY if the necessary system software is not initialized or running. + This call may return CUDA_ERROR_ILLEGAL_STATE if the system + configuration is in an illegal state. In such cases, to continue using + multicast, verify that the system configuration is in a valid state and + all required driver daemons are running properly. + Parameters ---------- mcHandle : :py:obj:`~.CUmemGenericAllocationHandle` @@ -34225,7 +34473,7 @@ def cuMulticastBindAddr(mcHandle, size_t mcOffset, memptr, size_t size, unsigned Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`, :py:obj:`~.CUDA_ERROR_SYSTEM_NOT_READY` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_PERMITTED`, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`, :py:obj:`~.CUDA_ERROR_SYSTEM_NOT_READY`, :py:obj:`~.CUDA_ERROR_ILLEGAL_STATE` See Also -------- @@ -34760,8 +35008,8 @@ def cuMemPrefetchAsync_v2(devPtr, size_t count, location not None : CUmemLocatio Pointer to be prefetched count : size_t Size in bytes - dstDevice : :py:obj:`~.CUmemLocation` - Destination device to prefetch to + location : :py:obj:`~.CUmemLocation` + Location to prefetch to flags : unsigned int flags for future use, must be zero now. hStream : :py:obj:`~.CUstream` or :py:obj:`~.cudaStream_t` @@ -34774,7 +35022,7 @@ def cuMemPrefetchAsync_v2(devPtr, size_t count, location not None : CUmemLocatio See Also -------- - :py:obj:`~.cuMemcpy`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cuMemAdvise`, :py:obj:`~.cuMemPrefetchAsync` :py:obj:`~.cudaMemPrefetchAsync_v2` + :py:obj:`~.cuMemcpy`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cuMemAdvise`, :py:obj:`~.cuMemPrefetchAsync`, :py:obj:`~.cudaMemPrefetchAsync_v2` """ cdef cydriver.CUstream cyhStream if hStream is None: @@ -34957,7 +35205,7 @@ def cuMemAdvise(devPtr, size_t count, advice not None : CUmem_advise, device): See Also -------- - :py:obj:`~.cuMemcpy`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cuMemPrefetchAsync`, :py:obj:`~.cuMemAdvise_v2` :py:obj:`~.cudaMemAdvise` + :py:obj:`~.cuMemcpy`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cuMemPrefetchAsync`, :py:obj:`~.cuMemAdvise_v2`, :py:obj:`~.cudaMemAdvise` """ cdef cydriver.CUdevice cydevice if device is None: @@ -35170,7 +35418,7 @@ def cuMemAdvise_v2(devPtr, size_t count, advice not None : CUmem_advise, locatio See Also -------- - :py:obj:`~.cuMemcpy`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cuMemPrefetchAsync`, :py:obj:`~.cuMemAdvise` :py:obj:`~.cudaMemAdvise` + :py:obj:`~.cuMemcpy`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cuMemPrefetchAsync`, :py:obj:`~.cuMemAdvise`, :py:obj:`~.cudaMemAdvise` """ cdef cydriver.CUdeviceptr cydevPtr if devPtr is None: @@ -35656,7 +35904,7 @@ def cuStreamCreateWithPriority(unsigned int flags, int priority): See Also -------- - :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice` :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreateWithPriority` + :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreateWithPriority` Notes ----- @@ -35701,7 +35949,7 @@ def cuStreamGetPriority(hStream): See Also -------- - :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice` :py:obj:`~.cudaStreamGetPriority` + :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice`, :py:obj:`~.cudaStreamGetPriority` """ cdef cydriver.CUstream cyhStream if hStream is None: @@ -35784,7 +36032,7 @@ def cuStreamGetFlags(hStream): See Also -------- - :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cudaStreamGetFlags` :py:obj:`~.cuStreamGetDevice` + :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cudaStreamGetFlags`, :py:obj:`~.cuStreamGetDevice` """ cdef cydriver.CUstream cyhStream if hStream is None: @@ -35981,7 +36229,7 @@ def cuStreamGetCtx_v2(hStream): See Also -------- - :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate` :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice` :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`, + :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate` :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`, """ cdef cydriver.CUstream cyhStream if hStream is None: @@ -36278,7 +36526,7 @@ def cuStreamBeginCaptureToGraph(hStream, hGraph, dependencies : Optional[Tuple[C See Also -------- - :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamIsCapturing`, :py:obj:`~.cuStreamEndCapture`, :py:obj:`~.cuThreadExchangeStreamCaptureMode`, :py:obj:`~.cuGraphAddNode`, + :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamIsCapturing`, :py:obj:`~.cuStreamEndCapture`, :py:obj:`~.cuThreadExchangeStreamCaptureMode`, :py:obj:`~.cuGraphAddNode` Notes ----- @@ -36668,7 +36916,7 @@ def cuStreamGetCaptureInfo_v3(hStream): See Also -------- - :py:obj:`~.cuStreamGetCaptureInfo` :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamIsCapturing`, :py:obj:`~.cuStreamUpdateCaptureDependencies` + :py:obj:`~.cuStreamGetCaptureInfo`, :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamIsCapturing`, :py:obj:`~.cuStreamUpdateCaptureDependencies` """ cdef cydriver.CUstream cyhStream if hStream is None: @@ -36812,7 +37060,7 @@ def cuStreamUpdateCaptureDependencies_v2(hStream, dependencies : Optional[Tuple[ See Also -------- - :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamGetCaptureInfo`, + :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamGetCaptureInfo` """ dependencyData = [] if dependencyData is None else dependencyData if not all(isinstance(_x, (CUgraphEdgeData,)) for _x in dependencyData): @@ -39527,7 +39775,7 @@ def cuLaunchKernelEx(config : Optional[CUlaunchConfig], f, kernelParams, void_pt kernel A, B may wait until A is complete. Alternatively, blocks of B may begin before all blocks of A have begun, for example: - - If B can claim execution resources unavaiable to A, for example if + - If B can claim execution resources unavailable to A, for example if they run on different GPUs. - If B is a higher priority than A. @@ -41302,8 +41550,8 @@ def cuGraphAddChildGraphNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] may not have any duplicate entries. A handle to the new node will be returned in `phGraphNode`. - If `hGraph` contains allocation or free nodes, this call will return an - error. + If `childGraph` contains allocation nodes, free nodes, or conditional + nodes, this call will return an error. The node executes an embedded child graph. The child graph is cloned in this call. @@ -42377,7 +42625,8 @@ def cuGraphAddMemAllocNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | - Nodes and edges of the graph cannot be deleted. - - The graph cannot be used in a child node. + - The graph can only be used in a child node if the ownership is moved + to the parent. - Only one instantiation of the graph may exist at any point in time. @@ -42504,7 +42753,8 @@ def cuGraphAddMemFreeNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | L - Nodes and edges of the graph cannot be deleted. - - The graph cannot be used in a child node. + - The graph can only be used in a child node if the ownership is moved + to the parent. - Only one instantiation of the graph may exist at any point in time. @@ -42780,6 +43030,10 @@ def cuGraphClone(originalGraph): See Also -------- :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphNodeFindInClone` + + Notes + ----- + : Cloning is not supported for graphs which contain memory allocation nodes, memory free nodes, or conditional nodes. """ cdef cydriver.CUgraph cyoriginalGraph if originalGraph is None: @@ -44267,7 +44521,7 @@ def cuGraphExecMemsetNodeSetParams(hGraphExec, hNode, memsetParams : Optional[CU aspects of the memset (width, height, element size or pitch) may cause the update to be rejected. Specifically, for 2d memsets, all dimension changes are rejected. For 1d memsets, changes in height are explicitly - rejected and other changes are oportunistically allowed if the + rejected and other changes are opportunistically allowed if the resulting work maps onto the work resources already allocated for the node. @@ -45039,7 +45293,7 @@ def cuGraphExecUpdate(hGraphExec, hGraph): - The source/destination memory must be allocated from the same contexts as the original source/destination memory. - - For 2d memsets, only address and assinged value may be updated. + - For 2d memsets, only address and assigned value may be updated. - For 1d memsets, updating dimensions is also allowed, but may fail if the resulting operation doesn't map onto the work resources @@ -45058,7 +45312,7 @@ def cuGraphExecUpdate(hGraphExec, hGraph): - Changing node parameters is not supported. - - Changeing parameters of nodes within the conditional body graph is + - Changing parameters of nodes within the conditional body graph is subject to the rules above. - Conditional handle flags and default values are updated as part of @@ -49244,7 +49498,7 @@ def cuTensorMapReplaceAddress(tensorMap : Optional[CUtensorMap], globalAddress): See Also -------- - :py:obj:`~.cuTensorMapEncodeTiled`, :py:obj:`~.cuTensorMapEncodeIm2col` :py:obj:`~.cuTensorMapEncodeIm2colWide` + :py:obj:`~.cuTensorMapEncodeTiled`, :py:obj:`~.cuTensorMapEncodeIm2col`, :py:obj:`~.cuTensorMapEncodeIm2colWide` """ cdef cydriver.CUtensorMap* cytensorMap_ptr = tensorMap._pvt_ptr if tensorMap != None else NULL cyglobalAddress = utils.HelperInputVoidPtr(globalAddress) @@ -50961,7 +51215,7 @@ def cuGreenCtxRecordEvent(hCtx, hEvent): Returns ------- CUresult - :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED` + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED` See Also -------- @@ -51017,7 +51271,7 @@ def cuGreenCtxWaitEvent(hCtx, hEvent): See Also -------- - :py:obj:`~.cuGreenCtxRecordEvent`, :py:obj:`~.cuStreamWaitEvent` :py:obj:`~.cuCtxRecordEvent`, :py:obj:`~.cuCtxWaitEvent` + :py:obj:`~.cuGreenCtxRecordEvent`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuCtxRecordEvent`, :py:obj:`~.cuCtxWaitEvent` Notes ----- @@ -51087,7 +51341,7 @@ def cuStreamGetGreenCtx(hStream): See Also -------- - :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuStreamGetCtx_v2`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice` :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags` + :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuStreamGetCtx_v2`, :py:obj:`~.cuGreenCtxStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags` """ cdef cydriver.CUstream cyhStream if hStream is None: @@ -51157,7 +51411,7 @@ def cuGreenCtxStreamCreate(greenCtx, unsigned int flags, int priority): See Also -------- - :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuGreenCtxCreate` :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice` :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreateWithPriority` + :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuGreenCtxCreate` :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamGetDevice`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreateWithPriority` Notes ----- @@ -51178,6 +51432,221 @@ def cuGreenCtxStreamCreate(greenCtx, unsigned int flags, int priority): return (_dict_CUresult[err], phStream) {{endif}} +{{if 'cuLogsRegisterCallback' in found_functions}} + +ctypedef struct cuLogsCallbackData_st: + cydriver.CUlogsCallback callback + void *userData + +ctypedef cuLogsCallbackData_st cuLogsCallbackData + +@cython.show_performance_hints(False) +cdef void cuLogsCallbackWrapper(void *data, cydriver.CUlogLevel logLevel, char *message, size_t length) nogil: + cdef cuLogsCallbackData *cbData = data + with gil: + cbData.callback(cbData.userData, logLevel, message, length) + +@cython.embedsignature(True) +def cuLogsRegisterCallback(callbackFunc, userData): + """ Register a callback function to receive error log messages. + + Parameters + ---------- + callbackFunc : :py:obj:`~.CUlogsCallback` + The function to register as a callback + userData : Any + A generic pointer to user data. This is passed into the callback + function. + + Returns + ------- + CUresult + :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_INVALID_VALUE` + callback_out : :py:obj:`~.CUlogsCallbackHandle` + Optional location to store the callback handle after it is + registered + """ + cdef cydriver.CUlogsCallback cycallbackFunc + if callbackFunc is None: + pcallbackFunc = 0 + elif isinstance(callbackFunc, (CUlogsCallback,)): + pcallbackFunc = int(callbackFunc) + else: + pcallbackFunc = int(CUlogsCallback(callbackFunc)) + cycallbackFunc = pcallbackFunc + cyuserData = utils.HelperInputVoidPtr(userData) + cdef void* cyuserData_ptr = cyuserData.cptr + + cdef cuLogsCallbackData *cbData = NULL + cbData = malloc(sizeof(cbData[0])) + if cbData == NULL: + return (CUresult.CUDA_ERROR_OUT_OF_MEMORY, None) + cbData.callback = cycallbackFunc + cbData.userData = cyuserData_ptr + + cdef CUlogsCallbackHandle callback_out = CUlogsCallbackHandle() + with nogil: + err = cydriver.cuLogsRegisterCallback(cuLogsCallbackWrapper, cbData, callback_out._pvt_ptr) + + if err != cydriver.CUDA_SUCCESS: + free(cbData) + else: + m_global._allocated[int(callback_out)] = cbData + if err != cydriver.CUDA_SUCCESS: + return (_dict_CUresult[err], None) + return (_dict_CUresult[err], callback_out) +{{endif}} + +{{if 'cuLogsUnregisterCallback' in found_functions}} + +@cython.embedsignature(True) +def cuLogsUnregisterCallback(callback): + """ Unregister a log message callback. + + Parameters + ---------- + callback : :py:obj:`~.CUlogsCallbackHandle` + The callback instance to unregister from receiving log messages + + Returns + ------- + CUresult + :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_INVALID_VALUE` + """ + cdef cydriver.CUlogsCallbackHandle cycallback + if callback is None: + pcallback = 0 + elif isinstance(callback, (CUlogsCallbackHandle,)): + pcallback = int(callback) + else: + pcallback = int(CUlogsCallbackHandle(callback)) + cycallback = pcallback + err = cydriver.cuLogsUnregisterCallback(cycallback) + if err == cydriver.CUDA_SUCCESS: + free(m_global._allocated[pcallback]) + m_global._allocated.erase(pcallback) + return (_dict_CUresult[err],) +{{endif}} + +{{if 'cuLogsCurrent' in found_functions}} + +@cython.embedsignature(True) +def cuLogsCurrent(unsigned int flags): + """ Sets log iterator to point to the end of log buffer, where the next message would be written. + + Parameters + ---------- + flags : unsigned int + Reserved for future use, must be 0 + + Returns + ------- + CUresult + :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_INVALID_VALUE` + iterator_out : :py:obj:`~.CUlogIterator` + Location to store an iterator to the current tail of the logs + """ + cdef CUlogIterator iterator_out = CUlogIterator() + err = cydriver.cuLogsCurrent(iterator_out._pvt_ptr, flags) + if err != cydriver.CUDA_SUCCESS: + return (_dict_CUresult[err], None) + return (_dict_CUresult[err], iterator_out) +{{endif}} + +{{if 'cuLogsDumpToFile' in found_functions}} + +@cython.embedsignature(True) +def cuLogsDumpToFile(iterator : Optional[CUlogIterator], char* pathToFile, unsigned int flags): + """ Dump accumulated driver logs into a file. + + Logs generated by the driver are stored in an internal buffer and can + be copied out using this API. This API dumps all driver logs starting + from `iterator` into `pathToFile` provided. + + Parameters + ---------- + iterator : :py:obj:`~.CUlogIterator` + Optional auto-advancing iterator specifying the starting log to + read. NULL value dumps all logs. + pathToFile : bytes + Path to output file for dumping logs + flags : unsigned int + Reserved for future use, must be 0 + + Returns + ------- + CUresult + :py:obj:`~.CUDA_SUCCESS` :py:obj:`~.CUDA_ERROR_INVALID_VALUE` + iterator : :py:obj:`~.CUlogIterator` + Optional auto-advancing iterator specifying the starting log to + read. NULL value dumps all logs. + + Notes + ----- + `iterator` is auto-advancing. Dumping logs will update the value of `iterator` to receive the next generated log. + + The driver reserves limited memory for storing logs. The oldest logs may be overwritten and become unrecoverable. An indication will appear in the destination outupt if the logs have been truncated. Call dump after each failed API to mitigate this risk. + """ + err = cydriver.cuLogsDumpToFile(iterator._pvt_ptr if iterator != None else NULL, pathToFile, flags) + if err != cydriver.CUDA_SUCCESS: + return (_dict_CUresult[err], None) + return (_dict_CUresult[err], iterator) +{{endif}} + +{{if 'cuLogsDumpToMemory' in found_functions}} + +@cython.embedsignature(True) +def cuLogsDumpToMemory(iterator : Optional[CUlogIterator], char* buffer, size_t size, unsigned int flags): + """ Dump accumulated driver logs into a buffer. + + Logs generated by the driver are stored in an internal buffer and can + be copied out using this API. This API dumps driver logs from + `iterator` into `buffer` up to the size specified in `*size`. The + driver will always null terminate the buffer but there will not be a + null character between log entries, only a newline \n. The driver will + then return the actual number of bytes written in `*size`, excluding + the null terminator. If there are no messages to dump, `*size` will be + set to 0 and the function will return :py:obj:`~.CUDA_SUCCESS`. If the + provided `buffer` is not large enough to hold any messages, `*size` + will be set to 0 and the function will return + :py:obj:`~.CUDA_ERROR_INVALID_VALUE`. + + Parameters + ---------- + iterator : :py:obj:`~.CUlogIterator` + Optional auto-advancing iterator specifying the starting log to + read. NULL value dumps all logs. + buffer : bytes + Pointer to dump logs + size : int + See description + flags : unsigned int + Reserved for future use, must be 0 + + Returns + ------- + CUresult + :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE` + iterator : :py:obj:`~.CUlogIterator` + Optional auto-advancing iterator specifying the starting log to + read. NULL value dumps all logs. + size : int + See description + + Notes + ----- + `iterator` is auto-advancing. Dumping logs will update the value of `iterator` to receive the next generated log. + + The driver reserves limited memory for storing logs. The maximum size of the buffer is 25600 bytes. The oldest logs may be overwritten and become unrecoverable. An indication will appear in the destination outupt if the logs have been truncated. Call dump after each failed API to mitigate this risk. + + If the provided value in `*size` is not large enough to hold all buffered messages, a message will be added at the head of the buffer indicating this. The driver then computes the number of messages it is able to store in `buffer` and writes it out. The final message in `buffer` will always be the most recent log message as of when the API is called. + """ + err = cydriver.cuLogsDumpToMemory(iterator._pvt_ptr if iterator != None else NULL, buffer, &size, flags) + if err != cydriver.CUDA_SUCCESS: + return (_dict_CUresult[err], None, None) + return (_dict_CUresult[err], iterator, size) +{{endif}} + {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}} @cython.embedsignature(True) @@ -53178,6 +53647,51 @@ def sizeof(objType): {{if 'CUmemPoolPtrExportData' in found_types}} if objType == CUmemPoolPtrExportData: return sizeof(cydriver.CUmemPoolPtrExportData){{endif}} + {{if 'CUmemcpyAttributes_st' in found_struct}} + if objType == CUmemcpyAttributes_st: + return sizeof(cydriver.CUmemcpyAttributes_st){{endif}} + {{if 'CUmemcpyAttributes_v1' in found_types}} + if objType == CUmemcpyAttributes_v1: + return sizeof(cydriver.CUmemcpyAttributes_v1){{endif}} + {{if 'CUmemcpyAttributes' in found_types}} + if objType == CUmemcpyAttributes: + return sizeof(cydriver.CUmemcpyAttributes){{endif}} + {{if 'CUoffset3D_st' in found_struct}} + if objType == CUoffset3D_st: + return sizeof(cydriver.CUoffset3D_st){{endif}} + {{if 'CUoffset3D_v1' in found_types}} + if objType == CUoffset3D_v1: + return sizeof(cydriver.CUoffset3D_v1){{endif}} + {{if 'CUoffset3D' in found_types}} + if objType == CUoffset3D: + return sizeof(cydriver.CUoffset3D){{endif}} + {{if 'CUextent3D_st' in found_struct}} + if objType == CUextent3D_st: + return sizeof(cydriver.CUextent3D_st){{endif}} + {{if 'CUextent3D_v1' in found_types}} + if objType == CUextent3D_v1: + return sizeof(cydriver.CUextent3D_v1){{endif}} + {{if 'CUextent3D' in found_types}} + if objType == CUextent3D: + return sizeof(cydriver.CUextent3D){{endif}} + {{if 'CUmemcpy3DOperand_st' in found_struct}} + if objType == CUmemcpy3DOperand_st: + return sizeof(cydriver.CUmemcpy3DOperand_st){{endif}} + {{if 'CUmemcpy3DOperand_v1' in found_types}} + if objType == CUmemcpy3DOperand_v1: + return sizeof(cydriver.CUmemcpy3DOperand_v1){{endif}} + {{if 'CUmemcpy3DOperand' in found_types}} + if objType == CUmemcpy3DOperand: + return sizeof(cydriver.CUmemcpy3DOperand){{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_st' in found_struct}} + if objType == CUDA_MEMCPY3D_BATCH_OP_st: + return sizeof(cydriver.CUDA_MEMCPY3D_BATCH_OP_st){{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP_v1' in found_types}} + if objType == CUDA_MEMCPY3D_BATCH_OP_v1: + return sizeof(cydriver.CUDA_MEMCPY3D_BATCH_OP_v1){{endif}} + {{if 'CUDA_MEMCPY3D_BATCH_OP' in found_types}} + if objType == CUDA_MEMCPY3D_BATCH_OP: + return sizeof(cydriver.CUDA_MEMCPY3D_BATCH_OP){{endif}} {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_v1_st' in found_struct}} if objType == CUDA_MEM_ALLOC_NODE_PARAMS_v1_st: return sizeof(cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_v1_st){{endif}} @@ -53247,51 +53761,6 @@ def sizeof(objType): {{if 'CUcheckpointUnlockArgs' in found_types}} if objType == CUcheckpointUnlockArgs: return sizeof(cydriver.CUcheckpointUnlockArgs){{endif}} - {{if 'CUmemcpyAttributes_st' in found_struct}} - if objType == CUmemcpyAttributes_st: - return sizeof(cydriver.CUmemcpyAttributes_st){{endif}} - {{if 'CUmemcpyAttributes_v1' in found_types}} - if objType == CUmemcpyAttributes_v1: - return sizeof(cydriver.CUmemcpyAttributes_v1){{endif}} - {{if 'CUmemcpyAttributes' in found_types}} - if objType == CUmemcpyAttributes: - return sizeof(cydriver.CUmemcpyAttributes){{endif}} - {{if 'CUoffset3D_st' in found_struct}} - if objType == CUoffset3D_st: - return sizeof(cydriver.CUoffset3D_st){{endif}} - {{if 'CUoffset3D_v1' in found_types}} - if objType == CUoffset3D_v1: - return sizeof(cydriver.CUoffset3D_v1){{endif}} - {{if 'CUoffset3D' in found_types}} - if objType == CUoffset3D: - return sizeof(cydriver.CUoffset3D){{endif}} - {{if 'CUextent3D_st' in found_struct}} - if objType == CUextent3D_st: - return sizeof(cydriver.CUextent3D_st){{endif}} - {{if 'CUextent3D_v1' in found_types}} - if objType == CUextent3D_v1: - return sizeof(cydriver.CUextent3D_v1){{endif}} - {{if 'CUextent3D' in found_types}} - if objType == CUextent3D: - return sizeof(cydriver.CUextent3D){{endif}} - {{if 'CUmemcpy3DOperand_st' in found_struct}} - if objType == CUmemcpy3DOperand_st: - return sizeof(cydriver.CUmemcpy3DOperand_st){{endif}} - {{if 'CUmemcpy3DOperand_v1' in found_types}} - if objType == CUmemcpy3DOperand_v1: - return sizeof(cydriver.CUmemcpy3DOperand_v1){{endif}} - {{if 'CUmemcpy3DOperand' in found_types}} - if objType == CUmemcpy3DOperand: - return sizeof(cydriver.CUmemcpy3DOperand){{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_st' in found_struct}} - if objType == CUDA_MEMCPY3D_BATCH_OP_st: - return sizeof(cydriver.CUDA_MEMCPY3D_BATCH_OP_st){{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP_v1' in found_types}} - if objType == CUDA_MEMCPY3D_BATCH_OP_v1: - return sizeof(cydriver.CUDA_MEMCPY3D_BATCH_OP_v1){{endif}} - {{if 'CUDA_MEMCPY3D_BATCH_OP' in found_types}} - if objType == CUDA_MEMCPY3D_BATCH_OP: - return sizeof(cydriver.CUDA_MEMCPY3D_BATCH_OP){{endif}} {{if 'CUmemDecompressParams_st' in found_struct}} if objType == CUmemDecompressParams_st: return sizeof(cydriver.CUmemDecompressParams_st){{endif}} @@ -53316,6 +53785,15 @@ def sizeof(objType): {{if 'struct CUdevResource_st' in found_types}} if objType == CUdevResource: return sizeof(cydriver.CUdevResource){{endif}} + {{if 'CUlogsCallbackHandle' in found_types}} + if objType == CUlogsCallbackHandle: + return sizeof(cydriver.CUlogsCallbackHandle){{endif}} + {{if 'CUlogsCallback' in found_types}} + if objType == CUlogsCallback: + return sizeof(cydriver.CUlogsCallback){{endif}} + {{if 'CUlogIterator' in found_types}} + if objType == CUlogIterator: + return sizeof(cydriver.CUlogIterator){{endif}} {{if True}} if objType == CUeglFrame_st: return sizeof(cydriver.CUeglFrame_st){{endif}} diff --git a/cuda_bindings/cuda/bindings/nvjitlink.pxd b/cuda_bindings/cuda/bindings/nvjitlink.pxd index 4c4a0f88e..e97fa1541 100644 --- a/cuda_bindings/cuda/bindings/nvjitlink.pxd +++ b/cuda_bindings/cuda/bindings/nvjitlink.pxd @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 12.0.1 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 12.0.1 to 12.9.0. Do not modify it directly. from libc.stdint cimport intptr_t, uint32_t diff --git a/cuda_bindings/cuda/bindings/nvjitlink.pyx b/cuda_bindings/cuda/bindings/nvjitlink.pyx index d8023ab5c..f874138e0 100644 --- a/cuda_bindings/cuda/bindings/nvjitlink.pyx +++ b/cuda_bindings/cuda/bindings/nvjitlink.pyx @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 12.0.1 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 12.0.1 to 12.9.0. Do not modify it directly. cimport cython # NOQA diff --git a/cuda_bindings/cuda/bindings/nvrtc.pxd.in b/cuda_bindings/cuda/bindings/nvrtc.pxd.in index ee01b204b..e3dd52de0 100644 --- a/cuda_bindings/cuda/bindings/nvrtc.pxd.in +++ b/cuda_bindings/cuda/bindings/nvrtc.pxd.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. cimport cuda.bindings.cynvrtc as cynvrtc cimport cuda.bindings._lib.utils as utils diff --git a/cuda_bindings/cuda/bindings/nvrtc.pyx.in b/cuda_bindings/cuda/bindings/nvrtc.pyx.in index cdaa312fc..717e58a1e 100644 --- a/cuda_bindings/cuda/bindings/nvrtc.pyx.in +++ b/cuda_bindings/cuda/bindings/nvrtc.pyx.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. from typing import List, Tuple, Any, Optional from enum import IntEnum import cython diff --git a/cuda_bindings/cuda/bindings/nvvm.pxd b/cuda_bindings/cuda/bindings/nvvm.pxd index dc8b2eea1..f8564f86a 100644 --- a/cuda_bindings/cuda/bindings/nvvm.pxd +++ b/cuda_bindings/cuda/bindings/nvvm.pxd @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 11.0.3 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 11.0.3 to 12.9.0. Do not modify it directly. from libc.stdint cimport intptr_t diff --git a/cuda_bindings/cuda/bindings/nvvm.pyx b/cuda_bindings/cuda/bindings/nvvm.pyx index 2a334994c..0a35150e5 100644 --- a/cuda_bindings/cuda/bindings/nvvm.pyx +++ b/cuda_bindings/cuda/bindings/nvvm.pyx @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE # -# This code was automatically generated across versions from 11.0.3 to 12.8.0. Do not modify it directly. +# This code was automatically generated across versions from 11.0.3 to 12.9.0. Do not modify it directly. cimport cython # NOQA diff --git a/cuda_bindings/cuda/bindings/runtime.pxd.in b/cuda_bindings/cuda/bindings/runtime.pxd.in index 2cc689b50..a6f56b452 100644 --- a/cuda_bindings/cuda/bindings/runtime.pxd.in +++ b/cuda_bindings/cuda/bindings/runtime.pxd.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. cimport cuda.bindings.cyruntime as cyruntime cimport cuda.bindings._lib.utils as utils cimport cuda.bindings.driver as driver @@ -3147,7 +3147,14 @@ cdef class cudaChildGraphNodeParams: {{if 'cudaChildGraphNodeParams.graph' in found_struct}} graph : cudaGraph_t The child graph to clone into the node for node creation, or a - handle to the graph owned by the node for node query + handle to the graph owned by the node for node query. The graph + must not contain conditional nodes. Graphs containing memory + allocation or memory free nodes must set the ownership to be moved + to the parent. + {{endif}} + {{if 'cudaChildGraphNodeParams.ownership' in found_struct}} + ownership : cudaGraphChildGraphNodeOwnership + The ownership relationship of the child graph node. {{endif}} Methods @@ -3928,11 +3935,12 @@ cdef class cudaAsyncNotificationInfo: ---------- {{if 'cudaAsyncNotificationInfo.type' in found_struct}} type : cudaAsyncNotificationType - + The type of notification being sent {{endif}} {{if 'cudaAsyncNotificationInfo.info' in found_struct}} info : anon_union10 - + Information about the notification. `typename` must be checked in + order to interpret this field. {{endif}} Methods @@ -4405,11 +4413,12 @@ cdef class cudaAsyncNotificationInfo_t(cudaAsyncNotificationInfo): ---------- {{if 'cudaAsyncNotificationInfo.type' in found_struct}} type : cudaAsyncNotificationType - + The type of notification being sent {{endif}} {{if 'cudaAsyncNotificationInfo.info' in found_struct}} info : anon_union10 - + Information about the notification. `typename` must be checked in + order to interpret this field. {{endif}} Methods diff --git a/cuda_bindings/cuda/bindings/runtime.pyx.in b/cuda_bindings/cuda/bindings/runtime.pyx.in index 86ce1006a..c3b8aa6f2 100644 --- a/cuda_bindings/cuda/bindings/runtime.pyx.in +++ b/cuda_bindings/cuda/bindings/runtime.pyx.in @@ -6,7 +6,7 @@ # this software and related documentation outside the terms of the EULA # is strictly prohibited. # -# This code was automatically generated with version 12.8.0. Do not modify it directly. +# This code was automatically generated with version 12.9.0. Do not modify it directly. from typing import List, Tuple, Any, Optional from enum import IntEnum import cython @@ -1457,6 +1457,8 @@ class cudaAsyncNotificationType(IntEnum): Types of async notification that can occur """ {{if 'cudaAsyncNotificationTypeOverBudget' in found_values}} + + #: Sent when the process has exceeded its device memory budget cudaAsyncNotificationTypeOverBudget = cyruntime.cudaAsyncNotificationType_enum.cudaAsyncNotificationTypeOverBudget{{endif}} _dict_cudaAsyncNotificationType = dict(((int(v), v) for k, v in cudaAsyncNotificationType.__members__.items())) @@ -3615,6 +3617,10 @@ class cudaDeviceAttr(IntEnum): #: Device supports CIG with D3D12. cudaDevAttrD3D12CigSupported = cyruntime.cudaDeviceAttr.cudaDevAttrD3D12CigSupported{{endif}} + {{if 'cudaDevAttrVulkanCigSupported' in found_values}} + + #: Device supports CIG with Vulkan. + cudaDevAttrVulkanCigSupported = cyruntime.cudaDeviceAttr.cudaDevAttrVulkanCigSupported{{endif}} {{if 'cudaDevAttrGpuPciDeviceId' in found_values}} #: The combined 16-bit PCI device ID and 16-bit PCI vendor ID. @@ -3624,6 +3630,14 @@ class cudaDeviceAttr(IntEnum): #: The combined 16-bit PCI subsystem ID and 16-bit PCI subsystem vendor #: ID. cudaDevAttrGpuPciSubsystemId = cyruntime.cudaDeviceAttr.cudaDevAttrGpuPciSubsystemId{{endif}} + {{if 'cudaDevAttrReserved141' in found_values}} + cudaDevAttrReserved141 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved141{{endif}} + {{if 'cudaDevAttrHostNumaMemoryPoolsSupported' in found_values}} + + #: Device supports HOST_NUMA location with the + #: :py:obj:`~.cudaMallocAsync` and :py:obj:`~.cudaMemPool` family of + #: APIs + cudaDevAttrHostNumaMemoryPoolsSupported = cyruntime.cudaDeviceAttr.cudaDevAttrHostNumaMemoryPoolsSupported{{endif}} {{if 'cudaDevAttrHostNumaMultinodeIpcSupported' in found_values}} #: Device supports HostNuma location IPC between nodes in a multi-node @@ -4376,6 +4390,33 @@ class cudaGraphNodeType(IntEnum): _dict_cudaGraphNodeType = dict(((int(v), v) for k, v in cudaGraphNodeType.__members__.items())) {{endif}} +{{if 'cudaGraphChildGraphNodeOwnership' in found_types}} + +class cudaGraphChildGraphNodeOwnership(IntEnum): + """ + Child graph node ownership + """ + {{if 'cudaGraphChildGraphOwnershipClone' in found_values}} + + #: Default behavior for a child graph node. Child graph is cloned into + #: the parent and memory allocation/free nodes can't be present in the + #: child graph. + cudaGraphChildGraphOwnershipClone = cyruntime.cudaGraphChildGraphNodeOwnership.cudaGraphChildGraphOwnershipClone{{endif}} + {{if 'cudaGraphChildGraphOwnershipMove' in found_values}} + + #: The child graph is moved to the parent. The handle to the child + #: graph is owned by the parent and will be destroyed when the parent + #: is destroyed. + #: + #: The following restrictions apply to child graphs after they have + #: been moved: Cannot be independently instantiated or destroyed; + #: Cannot be added as a child graph of a separate parent graph; Cannot + #: be used as an argument to cudaGraphExecUpdate; Cannot have + #: additional memory allocation or free nodes added. + cudaGraphChildGraphOwnershipMove = cyruntime.cudaGraphChildGraphNodeOwnership.cudaGraphChildGraphOwnershipMove{{endif}} + +_dict_cudaGraphChildGraphNodeOwnership = dict(((int(v), v) for k, v in cudaGraphChildGraphNodeOwnership.__members__.items())) +{{endif}} {{if 'cudaGraphExecUpdateResult' in found_types}} class cudaGraphExecUpdateResult(IntEnum): @@ -14623,7 +14664,14 @@ cdef class cudaChildGraphNodeParams: {{if 'cudaChildGraphNodeParams.graph' in found_struct}} graph : cudaGraph_t The child graph to clone into the node for node creation, or a - handle to the graph owned by the node for node query + handle to the graph owned by the node for node query. The graph + must not contain conditional nodes. Graphs containing memory + allocation or memory free nodes must set the ownership to be moved + to the parent. + {{endif}} + {{if 'cudaChildGraphNodeParams.ownership' in found_struct}} + ownership : cudaGraphChildGraphNodeOwnership + The ownership relationship of the child graph node. {{endif}} Methods @@ -14654,6 +14702,12 @@ cdef class cudaChildGraphNodeParams: except ValueError: str_list += ['graph : '] {{endif}} + {{if 'cudaChildGraphNodeParams.ownership' in found_struct}} + try: + str_list += ['ownership : ' + str(self.ownership)] + except ValueError: + str_list += ['ownership : '] + {{endif}} return '\n'.join(str_list) else: return '' @@ -14674,6 +14728,16 @@ cdef class cudaChildGraphNodeParams: cygraph = pgraph self._graph._pvt_ptr[0] = cygraph {{endif}} + {{if 'cudaChildGraphNodeParams.ownership' in found_struct}} + @property + def ownership(self): + if self._pvt_ptr[0].ownership not in _dict_cudaGraphChildGraphNodeOwnership: + return None + return _dict_cudaGraphChildGraphNodeOwnership[self._pvt_ptr[0].ownership] + @ownership.setter + def ownership(self, ownership not None : cudaGraphChildGraphNodeOwnership): + self._pvt_ptr[0].ownership = ownership.value + {{endif}} {{endif}} {{if 'cudaEventRecordNodeParams' in found_struct}} @@ -16851,11 +16915,12 @@ cdef class cudaAsyncNotificationInfo: ---------- {{if 'cudaAsyncNotificationInfo.type' in found_struct}} type : cudaAsyncNotificationType - + The type of notification being sent {{endif}} {{if 'cudaAsyncNotificationInfo.info' in found_struct}} info : anon_union10 - + Information about the notification. `typename` must be checked in + order to interpret this field. {{endif}} Methods @@ -27404,61 +27469,60 @@ def cudaMemRangeGetAttribute(size_t dataSize, attribute not None : cudaMemRangeA indication as to whether the prefetch operation to that location has completed or even begun. - - :py:obj:`~.cudaMemRangeAttributePreferredLocationType`: If this - attribute is specified, `data` will be interpreted as a - :py:obj:`~.cudaMemLocationType`, and `dataSize` must be - sizeof(cudaMemLocationType). The :py:obj:`~.cudaMemLocationType` - returned will be :py:obj:`~.cudaMemLocationTypeDevice` if all pages - in the memory range have the same GPU as their preferred location, - or :py:obj:`~.cudaMemLocationType` will be - :py:obj:`~.cudaMemLocationTypeHost` if all pages in the memory - range have the CPU as their preferred location, or or it will be - :py:obj:`~.cudaMemLocationTypeHostNuma` if all the pages in the - memory range have the same host NUMA node ID as their preferred - location or it will be :py:obj:`~.cudaMemLocationTypeInvalid` if - either all the pages don't have the same preferred location or some - of the pages don't have a preferred location at all. Note that the - actual location type of the pages in the memory range at the time - of the query may be different from the preferred location type. - - - :py:obj:`~.cudaMemRangeAttributePreferredLocationId`: If this - attribute is specified, `data` will be interpreted as a 32-bit integer, - and `dataSize` must be 4. If the - :py:obj:`~.cudaMemRangeAttributePreferredLocationType` query for the - same address range returns :py:obj:`~.cudaMemLocationTypeDevice`, it - will be a valid device ordinal or if it returns - :py:obj:`~.cudaMemLocationTypeHostNuma`, it will be a valid host NUMA - node ID or if it returns any other location type, the id should be - ignored. - - - :py:obj:`~.cudaMemRangeAttributeLastPrefetchLocationType`: If this - attribute is specified, `data` will be interpreted as a - :py:obj:`~.cudaMemLocationType`, and `dataSize` must be - sizeof(cudaMemLocationType). The result returned will be the last - location type to which all pages in the memory range were - prefetched explicitly via :py:obj:`~.cuMemPrefetchAsync`. The - :py:obj:`~.cudaMemLocationType` returned will be - :py:obj:`~.cudaMemLocationTypeDevice` if the last prefetch location - was the GPU or :py:obj:`~.cudaMemLocationTypeHost` if it was the - CPU or :py:obj:`~.cudaMemLocationTypeHostNuma` if the last prefetch - location was a specific host NUMA node. If any page in the memory - range was never explicitly prefetched or if all pages were not - prefetched to the same location, :py:obj:`~.CUmemLocationType` will - be :py:obj:`~.cudaMemLocationTypeInvalid`. Note that this simply - returns the last location type that the application requested to - prefetch the memory range to. It gives no indication as to whether - the prefetch operation to that location has completed or even - begun. - - - :py:obj:`~.cudaMemRangeAttributeLastPrefetchLocationId`: If this - attribute is specified, `data` will be interpreted as a 32-bit integer, - and `dataSize` must be 4. If the - :py:obj:`~.cudaMemRangeAttributeLastPrefetchLocationType` query for the - same address range returns :py:obj:`~.cudaMemLocationTypeDevice`, it - will be a valid device ordinal or if it returns - :py:obj:`~.cudaMemLocationTypeHostNuma`, it will be a valid host NUMA - node ID or if it returns any other location type, the id should be - ignored. + - :py:obj:`~.cudaMemRangeAttributePreferredLocationType`: If this + attribute is specified, `data` will be interpreted as a + :py:obj:`~.cudaMemLocationType`, and `dataSize` must be + sizeof(cudaMemLocationType). The :py:obj:`~.cudaMemLocationType` + returned will be :py:obj:`~.cudaMemLocationTypeDevice` if all pages + in the memory range have the same GPU as their preferred location, or + :py:obj:`~.cudaMemLocationType` will be + :py:obj:`~.cudaMemLocationTypeHost` if all pages in the memory range + have the CPU as their preferred location, or or it will be + :py:obj:`~.cudaMemLocationTypeHostNuma` if all the pages in the + memory range have the same host NUMA node ID as their preferred + location or it will be :py:obj:`~.cudaMemLocationTypeInvalid` if + either all the pages don't have the same preferred location or some + of the pages don't have a preferred location at all. Note that the + actual location type of the pages in the memory range at the time of + the query may be different from the preferred location type. + + - :py:obj:`~.cudaMemRangeAttributePreferredLocationId`: If this + attribute is specified, `data` will be interpreted as a 32-bit + integer, and `dataSize` must be 4. If the + :py:obj:`~.cudaMemRangeAttributePreferredLocationType` query for + the same address range returns + :py:obj:`~.cudaMemLocationTypeDevice`, it will be a valid device + ordinal or if it returns :py:obj:`~.cudaMemLocationTypeHostNuma`, + it will be a valid host NUMA node ID or if it returns any other + location type, the id should be ignored. + + - :py:obj:`~.cudaMemRangeAttributeLastPrefetchLocationType`: If this + attribute is specified, `data` will be interpreted as a + :py:obj:`~.cudaMemLocationType`, and `dataSize` must be + sizeof(cudaMemLocationType). The result returned will be the last + location type to which all pages in the memory range were prefetched + explicitly via :py:obj:`~.cuMemPrefetchAsync`. The + :py:obj:`~.cudaMemLocationType` returned will be + :py:obj:`~.cudaMemLocationTypeDevice` if the last prefetch location + was the GPU or :py:obj:`~.cudaMemLocationTypeHost` if it was the CPU + or :py:obj:`~.cudaMemLocationTypeHostNuma` if the last prefetch + location was a specific host NUMA node. If any page in the memory + range was never explicitly prefetched or if all pages were not + prefetched to the same location, :py:obj:`~.CUmemLocationType` will + be :py:obj:`~.cudaMemLocationTypeInvalid`. Note that this simply + returns the last location type that the application requested to + prefetch the memory range to. It gives no indication as to whether + the prefetch operation to that location has completed or even begun. + + - :py:obj:`~.cudaMemRangeAttributeLastPrefetchLocationId`: If this + attribute is specified, `data` will be interpreted as a 32-bit + integer, and `dataSize` must be 4. If the + :py:obj:`~.cudaMemRangeAttributeLastPrefetchLocationType` query for + the same address range returns + :py:obj:`~.cudaMemLocationTypeDevice`, it will be a valid device + ordinal or if it returns :py:obj:`~.cudaMemLocationTypeHostNuma`, + it will be a valid host NUMA node ID or if it returns any other + location type, the id should be ignored. Parameters ---------- @@ -30875,8 +30939,8 @@ def cudaGraphAddChildGraphNode(graph, pDependencies : Optional[Tuple[cudaGraphNo may not have any duplicate entries. A handle to the new node will be returned in `pGraphNode`. - If `hGraph` contains allocation or free nodes, this call will return an - error. + If `childGraph` contains allocation nodes, free nodes, or conditional + nodes, this call will return an error. The node executes an embedded child graph. The child graph is cloned in this call. @@ -31728,7 +31792,8 @@ def cudaGraphAddMemAllocNode(graph, pDependencies : Optional[Tuple[cudaGraphNode - Nodes and edges of the graph cannot be deleted. - - The graph cannot be used in a child node. + - The graph can only be used in a child node if the ownership is moved + to the parent. - Only one instantiation of the graph may exist at any point in time. @@ -31855,7 +31920,8 @@ def cudaGraphAddMemFreeNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_ - Nodes and edges of the graph cannot be deleted. - - The graph cannot be used in a child node. + - The graph can only be used in a child node if the ownership is moved + to the parent. - Only one instantiation of the graph may exist at any point in time. @@ -32102,6 +32168,10 @@ def cudaGraphClone(originalGraph): See Also -------- :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphNodeFindInClone` + + Notes + ----- + : Cloning is not supported for graphs which contain memory allocation nodes, memory free nodes, or conditional nodes. """ cdef cyruntime.cudaGraph_t cyoriginalGraph if originalGraph is None: @@ -33755,7 +33825,7 @@ def cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu aspects of the memset (width, height, element size or pitch) may cause the update to be rejected. Specifically, for 2d memsets, all dimension changes are rejected. For 1d memsets, changes in height are explicitly - rejected and other changes are oportunistically allowed if the + rejected and other changes are opportunistically allowed if the resulting work maps onto the work resources already allocated for the node. @@ -34338,7 +34408,7 @@ def cudaGraphExecUpdate(hGraphExec, hGraph): - The source/destination memory must be allocated from the same contexts as the original source/destination memory. - - For 2d memsets, only address and assinged value may be updated. + - For 2d memsets, only address and assigned value may be updated. - For 1d memsets, updating dimensions is also allowed, but may fail if the resulting operation doesn't map onto the work resources @@ -34353,7 +34423,7 @@ def cudaGraphExecUpdate(hGraphExec, hGraph): - Changing node parameters is not supported. - - Changeing parameters of nodes within the conditional body graph is + - Changing parameters of nodes within the conditional body graph is subject to the rules above. - Conditional handle flags and default values are updated as part of diff --git a/cuda_bindings/docs/source/module/driver.rst b/cuda_bindings/docs/source/module/driver.rst index 6f14cb16a..ca41b4fb7 100644 --- a/cuda_bindings/docs/source/module/driver.rst +++ b/cuda_bindings/docs/source/module/driver.rst @@ -70,6 +70,11 @@ Data types used by CUDA driver .. autoclass:: cuda.bindings.driver.CUgraphExecUpdateResultInfo_st .. autoclass:: cuda.bindings.driver.CUmemPoolProps_st .. autoclass:: cuda.bindings.driver.CUmemPoolPtrExportData_st +.. autoclass:: cuda.bindings.driver.CUmemcpyAttributes_st +.. autoclass:: cuda.bindings.driver.CUoffset3D_st +.. autoclass:: cuda.bindings.driver.CUextent3D_st +.. autoclass:: cuda.bindings.driver.CUmemcpy3DOperand_st +.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_BATCH_OP_st .. autoclass:: cuda.bindings.driver.CUDA_MEM_ALLOC_NODE_PARAMS_v1_st .. autoclass:: cuda.bindings.driver.CUDA_MEM_ALLOC_NODE_PARAMS_v2_st .. autoclass:: cuda.bindings.driver.CUDA_MEM_FREE_NODE_PARAMS_st @@ -81,11 +86,6 @@ Data types used by CUDA driver .. autoclass:: cuda.bindings.driver.CUcheckpointCheckpointArgs_st .. autoclass:: cuda.bindings.driver.CUcheckpointRestoreArgs_st .. autoclass:: cuda.bindings.driver.CUcheckpointUnlockArgs_st -.. autoclass:: cuda.bindings.driver.CUmemcpyAttributes_st -.. autoclass:: cuda.bindings.driver.CUoffset3D_st -.. autoclass:: cuda.bindings.driver.CUextent3D_st -.. autoclass:: cuda.bindings.driver.CUmemcpy3DOperand_st -.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_BATCH_OP_st .. autoclass:: cuda.bindings.driver.CUeglFrame_st .. autoclass:: cuda.bindings.driver.CUipcMem_flags @@ -443,6 +443,9 @@ Data types used by CUDA driver .. autoattribute:: cuda.bindings.driver.CUasyncNotificationType.CU_ASYNC_NOTIFICATION_TYPE_OVER_BUDGET + + Sent when the process has exceeded its device memory budget + .. autoclass:: cuda.bindings.driver.CUarray_format .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNSIGNED_INT8 @@ -1336,7 +1339,7 @@ Data types used by CUDA driver .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED - Link between the device and the host supports native atomic operations (this is a placeholder attribute, and is not supported on any current hardware) + Link between the device and the host supports native atomic operations .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO @@ -1651,6 +1654,12 @@ Data types used by CUDA driver The returned valued is the maximum length in bytes of a single decompress operation that is allowed. + .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_VULKAN_CIG_SUPPORTED + + + Device supports CIG with Vulkan. + + .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GPU_PCI_DEVICE_ID @@ -1663,6 +1672,18 @@ Data types used by CUDA driver The combined 16-bit PCI subsystem ID and 16-bit PCI subsystem vendor ID. + .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_NUMA_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED + + + Device supports HOST_NUMA location with the virtual memory management APIs like :py:obj:`~.cuMemCreate`, :py:obj:`~.cuMemMap` and related APIs + + + .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_NUMA_MEMORY_POOLS_SUPPORTED + + + Device supports HOST_NUMA location with the :py:obj:`~.cuMemAllocAsync` and :py:obj:`~.cuMemPool` family of APIs + + .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_NUMA_MULTINODE_IPC_SUPPORTED @@ -2591,10 +2612,22 @@ Data types used by CUDA driver Compute device class 10.1. + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_103 + + + Compute device class 10.3. + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_120 - Compute device class 12.0. Compute device class 9.0. with accelerated features. + Compute device class 12.0. + + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_121 + + + Compute device class 12.1. Compute device class 9.0. with accelerated features. .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_90A @@ -2612,11 +2645,53 @@ Data types used by CUDA driver .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_101A + Compute device class 10.3. with accelerated features. + + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_103A + + Compute device class 12.0. with accelerated features. .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_120A + + Compute device class 12.1. with accelerated features. + + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_121A + + + Compute device class 10.x with family features. + + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_100F + + + Compute device class 10.1 with family features. + + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_101F + + + Compute device class 10.3. with family features. + + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_103F + + + Compute device class 12.0. with family features. + + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_120F + + + Compute device class 12.1. with family features. + + + .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_121F + .. autoclass:: cuda.bindings.driver.CUjit_fallback .. autoattribute:: cuda.bindings.driver.CUjit_fallback.CU_PREFER_PTX @@ -3291,6 +3366,12 @@ Data types used by CUDA driver .. autoattribute:: cuda.bindings.driver.CUcigDataType.CIG_DATA_TYPE_D3D12_COMMAND_QUEUE + + .. autoattribute:: cuda.bindings.driver.CUcigDataType.CIG_DATA_TYPE_NV_BLOB + + + D3D12 Command Queue Handle + .. autoclass:: cuda.bindings.driver.CUlibraryOption .. autoattribute:: cuda.bindings.driver.CUlibraryOption.CU_LIBRARY_HOST_UNIVERSAL_FUNCTION_AND_DATA_TABLE @@ -4659,6 +4740,60 @@ Data types used by CUDA driver (value type = cuuint64_t) High watermark of the amount of memory from the pool that was in use by the application since the last time it was reset. High watermark can only be reset to zero. +.. autoclass:: cuda.bindings.driver.CUmemcpyFlags + + .. autoattribute:: cuda.bindings.driver.CUmemcpyFlags.CU_MEMCPY_FLAG_DEFAULT + + + .. autoattribute:: cuda.bindings.driver.CUmemcpyFlags.CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE + + + Hint to the driver to try and overlap the copy with compute work on the SMs. + +.. autoclass:: cuda.bindings.driver.CUmemcpySrcAccessOrder + + .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_INVALID + + + Default invalid. + + + .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_STREAM + + + Indicates that access to the source pointer must be in stream order. + + + .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_DURING_API_CALL + + + Indicates that access to the source pointer can be out of stream order and all accesses must be complete before the API call returns. This flag is suited for ephemeral sources (ex., stack variables) when it's known that no prior operations in the stream can be accessing the memory and also that the lifetime of the memory is limited to the scope that the source variable was declared in. Specifying this flag allows the driver to optimize the copy and removes the need for the user to synchronize the stream after the API call. + + + .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_ANY + + + Indicates that access to the source pointer can be out of stream order and the accesses can happen even after the API call returns. This flag is suited for host pointers allocated outside CUDA (ex., via malloc) when it's known that no prior operations in the stream can be accessing the memory. Specifying this flag allows the driver to optimize the copy on certain platforms. + + + .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_MAX + +.. autoclass:: cuda.bindings.driver.CUmemcpy3DOperandType + + .. autoattribute:: cuda.bindings.driver.CUmemcpy3DOperandType.CU_MEMCPY_OPERAND_TYPE_POINTER + + + Memcpy operand is a valid pointer. + + + .. autoattribute:: cuda.bindings.driver.CUmemcpy3DOperandType.CU_MEMCPY_OPERAND_TYPE_ARRAY + + + Memcpy operand is a CUarray. + + + .. autoattribute:: cuda.bindings.driver.CUmemcpy3DOperandType.CU_MEMCPY_OPERAND_TYPE_MAX + .. autoclass:: cuda.bindings.driver.CUgraphMem_attribute .. autoattribute:: cuda.bindings.driver.CUgraphMem_attribute.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT @@ -4684,6 +4819,23 @@ Data types used by CUDA driver (value type = cuuint64_t) High watermark of memory, in bytes, currently allocated for use by the CUDA graphs asynchronous allocator. +.. autoclass:: cuda.bindings.driver.CUgraphChildGraphNodeOwnership + + .. autoattribute:: cuda.bindings.driver.CUgraphChildGraphNodeOwnership.CU_GRAPH_CHILD_GRAPH_OWNERSHIP_CLONE + + + Default behavior for a child graph node. Child graph is cloned into the parent and memory allocation/free nodes can't be present in the child graph. + + + .. autoattribute:: cuda.bindings.driver.CUgraphChildGraphNodeOwnership.CU_GRAPH_CHILD_GRAPH_OWNERSHIP_MOVE + + + The child graph is moved to the parent. The handle to the child graph is owned by the parent and will be destroyed when the parent is destroyed. + + + + The following restrictions apply to child graphs after they have been moved: Cannot be independently instantiated or destroyed; Cannot be added as a child graph of a separate parent graph; Cannot be used as an argument to cuGraphExecUpdate; Cannot have additional memory allocation or free nodes added. + .. autoclass:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesOptions .. autoattribute:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesOptions.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST @@ -4910,60 +5062,6 @@ Data types used by CUDA driver Application entered an uncorrectable error during the checkpoint/restore process -.. autoclass:: cuda.bindings.driver.CUmemcpyFlags - - .. autoattribute:: cuda.bindings.driver.CUmemcpyFlags.CU_MEMCPY_FLAG_DEFAULT - - - .. autoattribute:: cuda.bindings.driver.CUmemcpyFlags.CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE - - - Hint to the driver to try and overlap the copy with compute work on the SMs. - -.. autoclass:: cuda.bindings.driver.CUmemcpySrcAccessOrder - - .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_INVALID - - - Default invalid. - - - .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_STREAM - - - Indicates that access to the source pointer must be in stream order. - - - .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_DURING_API_CALL - - - Indicates that access to the source pointer can be out of stream order and all accesses must be complete before the API call returns. This flag is suited for ephemeral sources (ex., stack variables) when it's known that no prior operations in the stream can be accessing the memory and also that the lifetime of the memory is limited to the scope that the source variable was declared in. Specifying this flag allows the driver to optimize the copy and removes the need for the user to synchronize the stream after the API call. - - - .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_ANY - - - Indicates that access to the source pointer can be out of stream order and the accesses can happen even after the API call returns. This flag is suited for host pointers allocated outside CUDA (ex., via malloc) when it's known that no prior operations in the stream can be accessing the memory. Specifying this flag allows the driver to optimize the copy on certain platforms. - - - .. autoattribute:: cuda.bindings.driver.CUmemcpySrcAccessOrder.CU_MEMCPY_SRC_ACCESS_ORDER_MAX - -.. autoclass:: cuda.bindings.driver.CUmemcpy3DOperandType - - .. autoattribute:: cuda.bindings.driver.CUmemcpy3DOperandType.CU_MEMCPY_OPERAND_TYPE_POINTER - - - Memcpy operand is a valid pointer. - - - .. autoattribute:: cuda.bindings.driver.CUmemcpy3DOperandType.CU_MEMCPY_OPERAND_TYPE_ARRAY - - - Memcpy operand is a CUarray. - - - .. autoattribute:: cuda.bindings.driver.CUmemcpy3DOperandType.CU_MEMCPY_OPERAND_TYPE_MAX - .. autoclass:: cuda.bindings.driver.CUeglFrameType .. autoattribute:: cuda.bindings.driver.CUeglFrameType.CU_EGL_FRAME_TYPE_ARRAY @@ -5841,6 +5939,16 @@ Data types used by CUDA driver .. autoclass:: cuda.bindings.driver.CUmemPoolProps .. autoclass:: cuda.bindings.driver.CUmemPoolPtrExportData_v1 .. autoclass:: cuda.bindings.driver.CUmemPoolPtrExportData +.. autoclass:: cuda.bindings.driver.CUmemcpyAttributes_v1 +.. autoclass:: cuda.bindings.driver.CUmemcpyAttributes +.. autoclass:: cuda.bindings.driver.CUoffset3D_v1 +.. autoclass:: cuda.bindings.driver.CUoffset3D +.. autoclass:: cuda.bindings.driver.CUextent3D_v1 +.. autoclass:: cuda.bindings.driver.CUextent3D +.. autoclass:: cuda.bindings.driver.CUmemcpy3DOperand_v1 +.. autoclass:: cuda.bindings.driver.CUmemcpy3DOperand +.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_BATCH_OP_v1 +.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_BATCH_OP .. autoclass:: cuda.bindings.driver.CUDA_MEM_ALLOC_NODE_PARAMS_v1 .. autoclass:: cuda.bindings.driver.CUDA_MEM_ALLOC_NODE_PARAMS .. autoclass:: cuda.bindings.driver.CUDA_MEM_ALLOC_NODE_PARAMS_v2 @@ -5853,16 +5961,6 @@ Data types used by CUDA driver .. autoclass:: cuda.bindings.driver.CUcheckpointCheckpointArgs .. autoclass:: cuda.bindings.driver.CUcheckpointRestoreArgs .. autoclass:: cuda.bindings.driver.CUcheckpointUnlockArgs -.. autoclass:: cuda.bindings.driver.CUmemcpyAttributes_v1 -.. autoclass:: cuda.bindings.driver.CUmemcpyAttributes -.. autoclass:: cuda.bindings.driver.CUoffset3D_v1 -.. autoclass:: cuda.bindings.driver.CUoffset3D -.. autoclass:: cuda.bindings.driver.CUextent3D_v1 -.. autoclass:: cuda.bindings.driver.CUextent3D -.. autoclass:: cuda.bindings.driver.CUmemcpy3DOperand_v1 -.. autoclass:: cuda.bindings.driver.CUmemcpy3DOperand -.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_BATCH_OP_v1 -.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_BATCH_OP .. autoclass:: cuda.bindings.driver.CUeglFrame_v1 .. autoclass:: cuda.bindings.driver.CUeglFrame .. autoclass:: cuda.bindings.driver.CUeglStreamConnection @@ -5903,6 +6001,7 @@ Data types used by CUDA driver See details of the \link_sync_behavior .. autoattribute:: cuda.bindings.driver.CU_COMPUTE_ACCELERATED_TARGET_BASE +.. autoattribute:: cuda.bindings.driver.CU_COMPUTE_FAMILY_TARGET_BASE .. autoattribute:: cuda.bindings.driver.CUDA_CB .. autoattribute:: cuda.bindings.driver.CU_GRAPH_COND_ASSIGN_DEFAULT @@ -6075,6 +6174,10 @@ Data types used by CUDA driver Enable seamless cube map filtering. Flag for :py:obj:`~.cuTexObjectCreate()` +.. autoattribute:: cuda.bindings.driver.CU_LAUNCH_KERNEL_REQUIRED_BLOCK_DIM + + Launch with the required block dimension. + .. autoattribute:: cuda.bindings.driver.CU_LAUNCH_PARAM_END_AS_INT C++ compile time constant for CU_LAUNCH_PARAM_END @@ -6293,6 +6396,12 @@ This section describes the memory management functions of the low-level CUDA dri Snappy is supported. + + .. autoattribute:: cuda.bindings.driver.CUmemDecompressAlgorithm.CU_MEM_DECOMPRESS_ALGORITHM_LZ4 + + + LZ4 is supported. + .. autoclass:: cuda.bindings.driver.CUmemDecompressParams .. autofunction:: cuda.bindings.driver.cuMemGetInfo .. autofunction:: cuda.bindings.driver.cuMemAlloc @@ -7047,6 +7156,27 @@ Even if the green contexts have disjoint SM partitions, it is not guaranteed tha .. autoattribute:: cuda.bindings.driver._CONCAT_INNER .. autoattribute:: cuda.bindings.driver._CONCAT_OUTER +Error Log Management Functions +------------------------------ + +This section describes the error log management functions of the low-level CUDA driver application programming interface. + +.. autoclass:: cuda.bindings.driver.CUlogLevel + + .. autoattribute:: cuda.bindings.driver.CUlogLevel.CU_LOG_LEVEL_ERROR + + + .. autoattribute:: cuda.bindings.driver.CUlogLevel.CU_LOG_LEVEL_WARNING + +.. autoclass:: cuda.bindings.driver.CUlogsCallbackHandle +.. autoclass:: cuda.bindings.driver.CUlogsCallback +.. autoclass:: cuda.bindings.driver.CUlogIterator +.. autofunction:: cuda.bindings.driver.cuLogsRegisterCallback +.. autofunction:: cuda.bindings.driver.cuLogsUnregisterCallback +.. autofunction:: cuda.bindings.driver.cuLogsCurrent +.. autofunction:: cuda.bindings.driver.cuLogsDumpToFile +.. autofunction:: cuda.bindings.driver.cuLogsDumpToMemory + CUDA Checkpointing ------------------ diff --git a/cuda_bindings/docs/source/module/nvrtc.rst b/cuda_bindings/docs/source/module/nvrtc.rst index 711b70de5..e52afa4dc 100644 --- a/cuda_bindings/docs/source/module/nvrtc.rst +++ b/cuda_bindings/docs/source/module/nvrtc.rst @@ -240,6 +240,16 @@ Enable device code optimization. When specified along with ``-G``\ , enables lim + - ``--Ofast-compile={0|min|mid|max}``\ (``-Ofc``\ ) + +Specify level to prefer device code compilation speed, where 'max' focuses only on the fastest compilation speed, 'mid' balances compile time and runtime, 'min' has a more minimal impact on both, and 0 (default) is normal compilation + + + + + + + - ``--ptxas-options``\ (``-Xptxas``\ ) @@ -398,6 +408,26 @@ Enable (disable) the generation of stack canaries in device code. + - ``--no-cache``\ (``-no-cache``\ ) + +Disable the use of cache for both ptx and cubin code generation. + + + + + + + + - ``--frandom-seed``\ (``-frandom-seed``\ ) + +The user specified random seed will be used to replace random numbers used in generating symbol names and variable names. The option can be used to generate deterministicly identical ptx and object files. If the input value is a valid number (decimal, octal, or hex), it will be used directly as the random seed. Otherwise, the CRC value of the passed string will be used instead. + + + + + + + - Preprocessing diff --git a/cuda_bindings/docs/source/module/runtime.rst b/cuda_bindings/docs/source/module/runtime.rst index 027e18dd6..b7301c913 100644 --- a/cuda_bindings/docs/source/module/runtime.rst +++ b/cuda_bindings/docs/source/module/runtime.rst @@ -4083,6 +4083,12 @@ Data types used by CUDA Runtime Device supports CIG with D3D12. + .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrVulkanCigSupported + + + Device supports CIG with Vulkan. + + .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrGpuPciDeviceId @@ -4095,6 +4101,15 @@ Data types used by CUDA Runtime The combined 16-bit PCI subsystem ID and 16-bit PCI subsystem vendor ID. + .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrReserved141 + + + .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrHostNumaMemoryPoolsSupported + + + Device supports HOST_NUMA location with the :py:obj:`~.cudaMallocAsync` and :py:obj:`~.cudaMemPool` family of APIs + + .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrHostNumaMultinodeIpcSupported @@ -4825,6 +4840,23 @@ Data types used by CUDA Runtime .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeCount +.. autoclass:: cuda.bindings.runtime.cudaGraphChildGraphNodeOwnership + + .. autoattribute:: cuda.bindings.runtime.cudaGraphChildGraphNodeOwnership.cudaGraphChildGraphOwnershipClone + + + Default behavior for a child graph node. Child graph is cloned into the parent and memory allocation/free nodes can't be present in the child graph. + + + .. autoattribute:: cuda.bindings.runtime.cudaGraphChildGraphNodeOwnership.cudaGraphChildGraphOwnershipMove + + + The child graph is moved to the parent. The handle to the child graph is owned by the parent and will be destroyed when the parent is destroyed. + + + + The following restrictions apply to child graphs after they have been moved: Cannot be independently instantiated or destroyed; Cannot be added as a child graph of a separate parent graph; Cannot be used as an argument to cudaGraphExecUpdate; Cannot have additional memory allocation or free nodes added. + .. autoclass:: cuda.bindings.runtime.cudaGraphDependencyType .. autoattribute:: cuda.bindings.runtime.cudaGraphDependencyType.cudaGraphDependencyTypeDefault @@ -5232,6 +5264,9 @@ Data types used by CUDA Runtime .. autoattribute:: cuda.bindings.runtime.cudaAsyncNotificationType.cudaAsyncNotificationTypeOverBudget + + Sent when the process has exceeded its device memory budget + .. autoclass:: cuda.bindings.runtime.cudaSurfaceBoundaryMode .. autoattribute:: cuda.bindings.runtime.cudaSurfaceBoundaryMode.cudaBoundaryModeZero diff --git a/cuda_bindings/docs/source/release.rst b/cuda_bindings/docs/source/release.rst index fcac1ee99..517055c18 100644 --- a/cuda_bindings/docs/source/release.rst +++ b/cuda_bindings/docs/source/release.rst @@ -6,7 +6,7 @@ Release Notes .. toctree:: :maxdepth: 3 - 12.X.Y + 12.9.0 12.8.0 12.6.2 12.6.1 diff --git a/cuda_bindings/docs/source/release/11.8.7-notes.rst b/cuda_bindings/docs/source/release/11.8.7-notes.rst index ef595d0df..29bc6293b 100644 --- a/cuda_bindings/docs/source/release/11.8.7-notes.rst +++ b/cuda_bindings/docs/source/release/11.8.7-notes.rst @@ -3,7 +3,7 @@ ``cuda-bindings`` 11.8.7 Release notes ====================================== -Released on **TBD**. +Released on May 5, 2025. Highlights @@ -17,3 +17,10 @@ Bug fixes --------- * Fix segfault when converting char* NULL to bytes + + +Known issues +------------ + +* Compute-sanitizer may report ``CUDA_ERROR_INVALID_CONTEXT`` when calling certain CUDA + runtime APIs such as ``cudaGetDevice()``. This is fixed in ``cuda-bindings`` 12.9.0. diff --git a/cuda_bindings/docs/source/release/12.X.Y-notes.rst b/cuda_bindings/docs/source/release/12.9.0-notes.rst similarity index 74% rename from cuda_bindings/docs/source/release/12.X.Y-notes.rst rename to cuda_bindings/docs/source/release/12.9.0-notes.rst index 49f5f6b9a..f9c5c8867 100644 --- a/cuda_bindings/docs/source/release/12.X.Y-notes.rst +++ b/cuda_bindings/docs/source/release/12.9.0-notes.rst @@ -1,26 +1,29 @@ .. SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE -``cuda-bindings`` 12.X.Y Release notes +``cuda-bindings`` 12.9.0 Release notes ====================================== -Released on **TBD**. +Released on May 5, 2025 Highlights ---------- * The ``cuda.bindings.nvvm`` Python module was added, wrapping the - `libNVVM C API `_. + `libNVVM C API `_ * Source build error checking added for missing required headers * Statically link CUDA Runtime instead of reimplementing it * Move stream callback wrappers to the Python layer * Return code construction is made faster * Failed API calls return None for non error code tuple elements + Bug fixes --------- * Fix segfault when converting char* NULL to bytes +* Compute-sanitizer may report ``CUDA_ERROR_INVALID_CONTEXT`` when calling certain CUDA + runtime APIs such as ``cudaGetDevice()`` Miscellaneous diff --git a/cuda_bindings/tests/test_cuda.py b/cuda_bindings/tests/test_cuda.py index 612401f3e..8d8443e88 100644 --- a/cuda_bindings/tests/test_cuda.py +++ b/cuda_bindings/tests/test_cuda.py @@ -1012,3 +1012,9 @@ def test_cuCheckpointProcessGetState_failure(): err, state = cuda.cuCheckpointProcessGetState(123434) assert err != cuda.CUresult.CUDA_SUCCESS assert state is None + + +def test_private_function_pointer_inspector(): + from cuda.bindings._bindings.cydriver import _inspect_function_pointer + + assert _inspect_function_pointer("__cuGetErrorString") != 0 diff --git a/cuda_core/cuda/core/experimental/_utils/driver_cu_result_explanations.py b/cuda_core/cuda/core/experimental/_utils/driver_cu_result_explanations.py index 38b7e2469..29772653d 100644 --- a/cuda_core/cuda/core/experimental/_utils/driver_cu_result_explanations.py +++ b/cuda_core/cuda/core/experimental/_utils/driver_cu_result_explanations.py @@ -19,7 +19,7 @@ # Also update the CUDA Toolkit version number below. # Done. -# CUDA Toolkit v12.8.0 +# CUDA Toolkit v12.9.0 DRIVER_CU_RESULT_EXPLANATIONS = { 0: ( "The API call returned with no errors. In the case of query calls, this also means that the operation" diff --git a/cuda_core/cuda/core/experimental/_utils/runtime_cuda_error_explanations.py b/cuda_core/cuda/core/experimental/_utils/runtime_cuda_error_explanations.py index 7eddfbad9..50191f94e 100644 --- a/cuda_core/cuda/core/experimental/_utils/runtime_cuda_error_explanations.py +++ b/cuda_core/cuda/core/experimental/_utils/runtime_cuda_error_explanations.py @@ -21,7 +21,7 @@ # Also update the CUDA Toolkit version number below. # Done. -# CUDA Toolkit v12.8.0 +# CUDA Toolkit v12.9.0 RUNTIME_CUDA_ERROR_EXPLANATIONS = { 0: ( "The API call returned with no errors. In the case of query calls, this also means that the operation"