diff --git a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxi.in b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxi.in index cf46efe91..6a0a0b3ad 100644 --- a/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxi.in +++ b/cuda_bindings/cuda/bindings/_bindings/cyruntime.pxi.in @@ -7,1458 +7,3162 @@ # is strictly prohibited. # # This code was automatically generated with version 12.8.0. Do not modify it directly. -cimport cuda.bindings.cyruntime as cyruntime +cimport cython +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 + +ctypedef unsigned int GLenum + +ctypedef unsigned int GLuint + +cdef extern from "": + cdef struct void: + pass +ctypedef void* EGLImageKHR + +cdef extern from "": + cdef struct void: + pass +ctypedef void* EGLStreamKHR + +ctypedef unsigned int EGLint + +cdef extern from "": + cdef struct void: + pass +ctypedef void* EGLSyncKHR + +ctypedef uint32_t VdpDevice + +ctypedef unsigned long long VdpGetProcAddress + +ctypedef uint32_t VdpVideoSurface + +ctypedef uint32_t VdpOutputSurface + +ctypedef cudaLaunchAttributeID cudaStreamAttrID + +ctypedef cudaLaunchAttributeID cudaKernelNodeAttrID + +ctypedef cudaLaunchAttributeValue cudaStreamAttrValue + +ctypedef cudaLaunchAttributeValue cudaKernelNodeAttrValue + +cdef enum cudaEglFrameType_enum: + cudaEglFrameTypeArray = 0 + cudaEglFrameTypePitch = 1 + +ctypedef cudaEglFrameType_enum cudaEglFrameType + +cdef enum cudaEglResourceLocationFlags_enum: + cudaEglResourceLocationSysmem = 0 + cudaEglResourceLocationVidmem = 1 + +ctypedef cudaEglResourceLocationFlags_enum cudaEglResourceLocationFlags + +cdef enum cudaEglColorFormat_enum: + cudaEglColorFormatYUV420Planar = 0 + cudaEglColorFormatYUV420SemiPlanar = 1 + cudaEglColorFormatYUV422Planar = 2 + cudaEglColorFormatYUV422SemiPlanar = 3 + cudaEglColorFormatARGB = 6 + cudaEglColorFormatRGBA = 7 + cudaEglColorFormatL = 8 + cudaEglColorFormatR = 9 + cudaEglColorFormatYUV444Planar = 10 + cudaEglColorFormatYUV444SemiPlanar = 11 + cudaEglColorFormatYUYV422 = 12 + cudaEglColorFormatUYVY422 = 13 + cudaEglColorFormatABGR = 14 + cudaEglColorFormatBGRA = 15 + cudaEglColorFormatA = 16 + cudaEglColorFormatRG = 17 + cudaEglColorFormatAYUV = 18 + cudaEglColorFormatYVU444SemiPlanar = 19 + cudaEglColorFormatYVU422SemiPlanar = 20 + cudaEglColorFormatYVU420SemiPlanar = 21 + cudaEglColorFormatY10V10U10_444SemiPlanar = 22 + cudaEglColorFormatY10V10U10_420SemiPlanar = 23 + cudaEglColorFormatY12V12U12_444SemiPlanar = 24 + cudaEglColorFormatY12V12U12_420SemiPlanar = 25 + cudaEglColorFormatVYUY_ER = 26 + cudaEglColorFormatUYVY_ER = 27 + cudaEglColorFormatYUYV_ER = 28 + cudaEglColorFormatYVYU_ER = 29 + cudaEglColorFormatYUVA_ER = 31 + cudaEglColorFormatAYUV_ER = 32 + cudaEglColorFormatYUV444Planar_ER = 33 + cudaEglColorFormatYUV422Planar_ER = 34 + cudaEglColorFormatYUV420Planar_ER = 35 + cudaEglColorFormatYUV444SemiPlanar_ER = 36 + cudaEglColorFormatYUV422SemiPlanar_ER = 37 + cudaEglColorFormatYUV420SemiPlanar_ER = 38 + cudaEglColorFormatYVU444Planar_ER = 39 + cudaEglColorFormatYVU422Planar_ER = 40 + cudaEglColorFormatYVU420Planar_ER = 41 + cudaEglColorFormatYVU444SemiPlanar_ER = 42 + cudaEglColorFormatYVU422SemiPlanar_ER = 43 + cudaEglColorFormatYVU420SemiPlanar_ER = 44 + cudaEglColorFormatBayerRGGB = 45 + cudaEglColorFormatBayerBGGR = 46 + cudaEglColorFormatBayerGRBG = 47 + cudaEglColorFormatBayerGBRG = 48 + cudaEglColorFormatBayer10RGGB = 49 + cudaEglColorFormatBayer10BGGR = 50 + cudaEglColorFormatBayer10GRBG = 51 + cudaEglColorFormatBayer10GBRG = 52 + cudaEglColorFormatBayer12RGGB = 53 + cudaEglColorFormatBayer12BGGR = 54 + cudaEglColorFormatBayer12GRBG = 55 + cudaEglColorFormatBayer12GBRG = 56 + cudaEglColorFormatBayer14RGGB = 57 + cudaEglColorFormatBayer14BGGR = 58 + cudaEglColorFormatBayer14GRBG = 59 + cudaEglColorFormatBayer14GBRG = 60 + cudaEglColorFormatBayer20RGGB = 61 + cudaEglColorFormatBayer20BGGR = 62 + cudaEglColorFormatBayer20GRBG = 63 + cudaEglColorFormatBayer20GBRG = 64 + cudaEglColorFormatYVU444Planar = 65 + cudaEglColorFormatYVU422Planar = 66 + cudaEglColorFormatYVU420Planar = 67 + cudaEglColorFormatBayerIspRGGB = 68 + cudaEglColorFormatBayerIspBGGR = 69 + cudaEglColorFormatBayerIspGRBG = 70 + cudaEglColorFormatBayerIspGBRG = 71 + cudaEglColorFormatBayerBCCR = 72 + cudaEglColorFormatBayerRCCB = 73 + cudaEglColorFormatBayerCRBC = 74 + cudaEglColorFormatBayerCBRC = 75 + cudaEglColorFormatBayer10CCCC = 76 + cudaEglColorFormatBayer12BCCR = 77 + cudaEglColorFormatBayer12RCCB = 78 + cudaEglColorFormatBayer12CRBC = 79 + cudaEglColorFormatBayer12CBRC = 80 + cudaEglColorFormatBayer12CCCC = 81 + cudaEglColorFormatY = 82 + cudaEglColorFormatYUV420SemiPlanar_2020 = 83 + cudaEglColorFormatYVU420SemiPlanar_2020 = 84 + cudaEglColorFormatYUV420Planar_2020 = 85 + cudaEglColorFormatYVU420Planar_2020 = 86 + cudaEglColorFormatYUV420SemiPlanar_709 = 87 + cudaEglColorFormatYVU420SemiPlanar_709 = 88 + cudaEglColorFormatYUV420Planar_709 = 89 + cudaEglColorFormatYVU420Planar_709 = 90 + cudaEglColorFormatY10V10U10_420SemiPlanar_709 = 91 + cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = 92 + cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = 93 + cudaEglColorFormatY10V10U10_422SemiPlanar = 94 + cudaEglColorFormatY10V10U10_422SemiPlanar_709 = 95 + cudaEglColorFormatY_ER = 96 + cudaEglColorFormatY_709_ER = 97 + cudaEglColorFormatY10_ER = 98 + cudaEglColorFormatY10_709_ER = 99 + cudaEglColorFormatY12_ER = 100 + cudaEglColorFormatY12_709_ER = 101 + cudaEglColorFormatYUVA = 102 + cudaEglColorFormatYVYU = 104 + cudaEglColorFormatVYUY = 105 + cudaEglColorFormatY10V10U10_420SemiPlanar_ER = 106 + cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = 107 + cudaEglColorFormatY10V10U10_444SemiPlanar_ER = 108 + cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = 109 + cudaEglColorFormatY12V12U12_420SemiPlanar_ER = 110 + cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = 111 + cudaEglColorFormatY12V12U12_444SemiPlanar_ER = 112 + cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = 113 + cudaEglColorFormatUYVY709 = 114 + cudaEglColorFormatUYVY709_ER = 115 + cudaEglColorFormatUYVY2020 = 116 +cdef extern from "cuda_runtime_api.h" nogil: + {{if 'cudaDeviceReset' in found_functions}} - cyruntime.cudaError_t cudaDeviceReset() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceReset() {{endif}} {{if 'cudaDeviceSynchronize' in found_functions}} - cyruntime.cudaError_t cudaDeviceSynchronize() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceSynchronize() {{endif}} {{if 'cudaDeviceSetLimit' in found_functions}} - cyruntime.cudaError_t cudaDeviceSetLimit(cyruntime.cudaLimit limit, size_t value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) {{endif}} {{if 'cudaDeviceGetLimit' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetLimit(size_t* pValue, cyruntime.cudaLimit limit) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) {{endif}} {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cyruntime.cudaChannelFormatDesc* fmtDesc, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) {{endif}} {{if 'cudaDeviceGetCacheConfig' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetCacheConfig(cyruntime.cudaFuncCache* pCacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) {{endif}} {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) {{endif}} {{if 'cudaDeviceSetCacheConfig' in found_functions}} - cyruntime.cudaError_t cudaDeviceSetCacheConfig(cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) {{endif}} {{if 'cudaDeviceGetByPCIBusId' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) {{endif}} {{if 'cudaDeviceGetPCIBusId' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) {{endif}} {{if 'cudaIpcGetEventHandle' in found_functions}} - cyruntime.cudaError_t cudaIpcGetEventHandle(cyruntime.cudaIpcEventHandle_t* handle, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) {{endif}} {{if 'cudaIpcOpenEventHandle' in found_functions}} - cyruntime.cudaError_t cudaIpcOpenEventHandle(cyruntime.cudaEvent_t* event, cyruntime.cudaIpcEventHandle_t handle) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) {{endif}} {{if 'cudaIpcGetMemHandle' in found_functions}} - cyruntime.cudaError_t cudaIpcGetMemHandle(cyruntime.cudaIpcMemHandle_t* handle, void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) {{endif}} {{if 'cudaIpcOpenMemHandle' in found_functions}} - cyruntime.cudaError_t cudaIpcOpenMemHandle(void** devPtr, cyruntime.cudaIpcMemHandle_t handle, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) {{endif}} {{if 'cudaIpcCloseMemHandle' in found_functions}} - cyruntime.cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaIpcCloseMemHandle(void* devPtr) {{endif}} {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}} - cyruntime.cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cyruntime.cudaFlushGPUDirectRDMAWritesTarget target, cyruntime.cudaFlushGPUDirectRDMAWritesScope scope) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) {{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 + cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) {{endif}} {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}} - cyruntime.cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cyruntime.cudaAsyncCallbackHandle_t callback) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) {{endif}} {{if 'cudaDeviceGetSharedMemConfig' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetSharedMemConfig(cyruntime.cudaSharedMemConfig* pConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) {{endif}} {{if 'cudaDeviceSetSharedMemConfig' in found_functions}} - cyruntime.cudaError_t cudaDeviceSetSharedMemConfig(cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) {{endif}} {{if 'cudaGetLastError' in found_functions}} - cyruntime.cudaError_t cudaGetLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetLastError() {{endif}} {{if 'cudaPeekAtLastError' in found_functions}} - cyruntime.cudaError_t cudaPeekAtLastError() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaPeekAtLastError() {{endif}} {{if 'cudaGetErrorName' in found_functions}} - const char* cudaGetErrorName(cyruntime.cudaError_t error) except ?NULL nogil + const char* cudaGetErrorName(cudaError_t error) {{endif}} {{if 'cudaGetErrorString' in found_functions}} - const char* cudaGetErrorString(cyruntime.cudaError_t error) except ?NULL nogil + const char* cudaGetErrorString(cudaError_t error) {{endif}} {{if 'cudaGetDeviceCount' in found_functions}} - cyruntime.cudaError_t cudaGetDeviceCount(int* count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetDeviceCount(int* count) {{endif}} {{if 'cudaGetDeviceProperties_v2' in found_functions}} - cyruntime.cudaError_t cudaGetDeviceProperties_v2(cyruntime.cudaDeviceProp* prop, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetDeviceProperties_v2(cudaDeviceProp* prop, int device) {{endif}} {{if 'cudaDeviceGetAttribute' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetAttribute(int* value, cyruntime.cudaDeviceAttr attr, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) {{endif}} {{if 'cudaDeviceGetDefaultMemPool' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetDefaultMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) {{endif}} {{if 'cudaDeviceSetMemPool' in found_functions}} - cyruntime.cudaError_t cudaDeviceSetMemPool(int device, cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) {{endif}} {{if 'cudaDeviceGetMemPool' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetMemPool(cyruntime.cudaMemPool_t* memPool, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) {{endif}} {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) {{endif}} {{if 'cudaDeviceGetP2PAttribute' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetP2PAttribute(int* value, cyruntime.cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) {{endif}} {{if 'cudaChooseDevice' in found_functions}} - cyruntime.cudaError_t cudaChooseDevice(int* device, const cyruntime.cudaDeviceProp* prop) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) {{endif}} {{if 'cudaInitDevice' in found_functions}} - cyruntime.cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) {{endif}} {{if 'cudaSetDevice' in found_functions}} - cyruntime.cudaError_t cudaSetDevice(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaSetDevice(int device) {{endif}} {{if 'cudaGetDevice' in found_functions}} - cyruntime.cudaError_t cudaGetDevice(int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetDevice(int* device) {{endif}} {{if 'cudaSetDeviceFlags' in found_functions}} - cyruntime.cudaError_t cudaSetDeviceFlags(unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaSetDeviceFlags(unsigned int flags) {{endif}} {{if 'cudaGetDeviceFlags' in found_functions}} - cyruntime.cudaError_t cudaGetDeviceFlags(unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetDeviceFlags(unsigned int* flags) {{endif}} {{if 'cudaStreamCreate' in found_functions}} - cyruntime.cudaError_t cudaStreamCreate(cyruntime.cudaStream_t* pStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamCreate(cudaStream_t* pStream) {{endif}} {{if 'cudaStreamCreateWithFlags' in found_functions}} - cyruntime.cudaError_t cudaStreamCreateWithFlags(cyruntime.cudaStream_t* pStream, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) {{endif}} {{if 'cudaStreamCreateWithPriority' in found_functions}} - cyruntime.cudaError_t cudaStreamCreateWithPriority(cyruntime.cudaStream_t* pStream, unsigned int flags, int priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) {{endif}} {{if 'cudaStreamGetPriority' in found_functions}} - cyruntime.cudaError_t cudaStreamGetPriority(cyruntime.cudaStream_t hStream, int* priority) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) {{endif}} {{if 'cudaStreamGetFlags' in found_functions}} - cyruntime.cudaError_t cudaStreamGetFlags(cyruntime.cudaStream_t hStream, unsigned int* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) {{endif}} {{if 'cudaStreamGetId' in found_functions}} - cyruntime.cudaError_t cudaStreamGetId(cyruntime.cudaStream_t hStream, unsigned long long* streamId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) {{endif}} {{if 'cudaStreamGetDevice' in found_functions}} - cyruntime.cudaError_t cudaStreamGetDevice(cyruntime.cudaStream_t hStream, int* device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamGetDevice(cudaStream_t hStream, int* device) {{endif}} {{if 'cudaCtxResetPersistingL2Cache' in found_functions}} - cyruntime.cudaError_t cudaCtxResetPersistingL2Cache() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaCtxResetPersistingL2Cache() {{endif}} {{if 'cudaStreamCopyAttributes' in found_functions}} - cyruntime.cudaError_t cudaStreamCopyAttributes(cyruntime.cudaStream_t dst, cyruntime.cudaStream_t src) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) {{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 + cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) {{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 + cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) {{endif}} {{if 'cudaStreamDestroy' in found_functions}} - cyruntime.cudaError_t cudaStreamDestroy(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamDestroy(cudaStream_t stream) {{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 + cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) {{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 + cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) {{endif}} {{if 'cudaStreamSynchronize' in found_functions}} - cyruntime.cudaError_t cudaStreamSynchronize(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamSynchronize(cudaStream_t stream) {{endif}} {{if 'cudaStreamQuery' in found_functions}} - cyruntime.cudaError_t cudaStreamQuery(cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamQuery(cudaStream_t stream) {{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 + cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) {{endif}} {{if 'cudaStreamBeginCapture' in found_functions}} - cyruntime.cudaError_t cudaStreamBeginCapture(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureMode mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) {{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 + cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) {{endif}} {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}} - cyruntime.cudaError_t cudaThreadExchangeStreamCaptureMode(cyruntime.cudaStreamCaptureMode* mode) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) {{endif}} {{if 'cudaStreamEndCapture' in found_functions}} - cyruntime.cudaError_t cudaStreamEndCapture(cyruntime.cudaStream_t stream, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) {{endif}} {{if 'cudaStreamIsCapturing' in found_functions}} - cyruntime.cudaError_t cudaStreamIsCapturing(cyruntime.cudaStream_t stream, cyruntime.cudaStreamCaptureStatus* pCaptureStatus) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) {{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 + 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) {{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 + 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) {{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 + 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) {{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 + cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) {{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 + cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) {{endif}} {{if 'cudaEventCreate' in found_functions}} - cyruntime.cudaError_t cudaEventCreate(cyruntime.cudaEvent_t* event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaEventCreate(cudaEvent_t* event) {{endif}} {{if 'cudaEventCreateWithFlags' in found_functions}} - cyruntime.cudaError_t cudaEventCreateWithFlags(cyruntime.cudaEvent_t* event, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) {{endif}} {{if 'cudaEventRecord' in found_functions}} - cyruntime.cudaError_t cudaEventRecord(cyruntime.cudaEvent_t event, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) {{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 + cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) {{endif}} {{if 'cudaEventQuery' in found_functions}} - cyruntime.cudaError_t cudaEventQuery(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaEventQuery(cudaEvent_t event) {{endif}} {{if 'cudaEventSynchronize' in found_functions}} - cyruntime.cudaError_t cudaEventSynchronize(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaEventSynchronize(cudaEvent_t event) {{endif}} {{if 'cudaEventDestroy' in found_functions}} - cyruntime.cudaError_t cudaEventDestroy(cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaEventDestroy(cudaEvent_t event) {{endif}} {{if 'cudaEventElapsedTime' in found_functions}} - cyruntime.cudaError_t cudaEventElapsedTime(float* ms, cyruntime.cudaEvent_t start, cyruntime.cudaEvent_t end) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) {{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 + cudaError_t cudaEventElapsedTime_v2(float* ms, cudaEvent_t start, cudaEvent_t end) {{endif}} {{if 'cudaImportExternalMemory' in found_functions}} - cyruntime.cudaError_t cudaImportExternalMemory(cyruntime.cudaExternalMemory_t* extMem_out, const cyruntime.cudaExternalMemoryHandleDesc* memHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) {{endif}} {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}} - cyruntime.cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cyruntime.cudaExternalMemory_t extMem, const cyruntime.cudaExternalMemoryBufferDesc* bufferDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) {{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 + cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) {{endif}} {{if 'cudaDestroyExternalMemory' in found_functions}} - cyruntime.cudaError_t cudaDestroyExternalMemory(cyruntime.cudaExternalMemory_t extMem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) {{endif}} {{if 'cudaImportExternalSemaphore' in found_functions}} - cyruntime.cudaError_t cudaImportExternalSemaphore(cyruntime.cudaExternalSemaphore_t* extSem_out, const cyruntime.cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) {{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 + cudaError_t cudaSignalExternalSemaphoresAsync_v2_ptsz(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) {{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 + cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) {{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 + cudaError_t cudaWaitExternalSemaphoresAsync_v2_ptsz(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) {{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 + cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) {{endif}} {{if 'cudaDestroyExternalSemaphore' in found_functions}} - cyruntime.cudaError_t cudaDestroyExternalSemaphore(cyruntime.cudaExternalSemaphore_t extSem) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) {{endif}} {{if 'cudaFuncSetCacheConfig' in found_functions}} - cyruntime.cudaError_t cudaFuncSetCacheConfig(const void* func, cyruntime.cudaFuncCache cacheConfig) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) {{endif}} {{if 'cudaFuncGetAttributes' in found_functions}} - cyruntime.cudaError_t cudaFuncGetAttributes(cyruntime.cudaFuncAttributes* attr, const void* func) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) {{endif}} {{if 'cudaFuncSetAttribute' in found_functions}} - cyruntime.cudaError_t cudaFuncSetAttribute(const void* func, cyruntime.cudaFuncAttribute attr, int value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) {{endif}} {{if 'cudaLaunchHostFunc' in found_functions}} - cyruntime.cudaError_t cudaLaunchHostFunc(cyruntime.cudaStream_t stream, cyruntime.cudaHostFn_t fn, void* userData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) {{endif}} {{if 'cudaFuncSetSharedMemConfig' in found_functions}} - cyruntime.cudaError_t cudaFuncSetSharedMemConfig(const void* func, cyruntime.cudaSharedMemConfig config) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) {{endif}} {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}} - cyruntime.cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) {{endif}} {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}} - cyruntime.cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) {{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 + cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) {{endif}} {{if 'cudaMallocManaged' in found_functions}} - cyruntime.cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) {{endif}} {{if 'cudaMalloc' in found_functions}} - cyruntime.cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMalloc(void** devPtr, size_t size) {{endif}} {{if 'cudaMallocHost' in found_functions}} - cyruntime.cudaError_t cudaMallocHost(void** ptr, size_t size) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMallocHost(void** ptr, size_t size) {{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 + cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) {{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 + cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) {{endif}} {{if 'cudaFree' in found_functions}} - cyruntime.cudaError_t cudaFree(void* devPtr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFree(void* devPtr) {{endif}} {{if 'cudaFreeHost' in found_functions}} - cyruntime.cudaError_t cudaFreeHost(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFreeHost(void* ptr) {{endif}} {{if 'cudaFreeArray' in found_functions}} - cyruntime.cudaError_t cudaFreeArray(cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFreeArray(cudaArray_t array) {{endif}} {{if 'cudaFreeMipmappedArray' in found_functions}} - cyruntime.cudaError_t cudaFreeMipmappedArray(cyruntime.cudaMipmappedArray_t mipmappedArray) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) {{endif}} {{if 'cudaHostAlloc' in found_functions}} - cyruntime.cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) {{endif}} {{if 'cudaHostRegister' in found_functions}} - cyruntime.cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) {{endif}} {{if 'cudaHostUnregister' in found_functions}} - cyruntime.cudaError_t cudaHostUnregister(void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaHostUnregister(void* ptr) {{endif}} {{if 'cudaHostGetDevicePointer' in found_functions}} - cyruntime.cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) {{endif}} {{if 'cudaHostGetFlags' in found_functions}} - cyruntime.cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) {{endif}} {{if 'cudaMalloc3D' in found_functions}} - cyruntime.cudaError_t cudaMalloc3D(cyruntime.cudaPitchedPtr* pitchedDevPtr, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) {{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 + cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) {{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 + cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) {{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 + cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) {{endif}} {{if 'cudaMemcpy3D' in found_functions}} - cyruntime.cudaError_t cudaMemcpy3D(const cyruntime.cudaMemcpy3DParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) {{endif}} {{if 'cudaMemcpy3DPeer' in found_functions}} - cyruntime.cudaError_t cudaMemcpy3DPeer(const cyruntime.cudaMemcpy3DPeerParms* p) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) {{endif}} {{if 'cudaMemcpy3DAsync' in found_functions}} - cyruntime.cudaError_t cudaMemcpy3DAsync(const cyruntime.cudaMemcpy3DParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) {{endif}} {{if 'cudaMemcpy3DPeerAsync' in found_functions}} - cyruntime.cudaError_t cudaMemcpy3DPeerAsync(const cyruntime.cudaMemcpy3DPeerParms* p, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) {{endif}} {{if 'cudaMemGetInfo' in found_functions}} - cyruntime.cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemGetInfo(size_t* free, size_t* total) {{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 + cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) {{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 + cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) {{endif}} {{if 'cudaArrayGetMemoryRequirements' in found_functions}} - cyruntime.cudaError_t cudaArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaArray_t array, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) {{endif}} {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}} - cyruntime.cudaError_t cudaMipmappedArrayGetMemoryRequirements(cyruntime.cudaArrayMemoryRequirements* memoryRequirements, cyruntime.cudaMipmappedArray_t mipmap, int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) {{endif}} {{if 'cudaArrayGetSparseProperties' in found_functions}} - cyruntime.cudaError_t cudaArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaArray_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) {{endif}} {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}} - cyruntime.cudaError_t cudaMipmappedArrayGetSparseProperties(cyruntime.cudaArraySparseProperties* sparseProperties, cyruntime.cudaMipmappedArray_t mipmap) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) {{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 + cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) {{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 + cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) {{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 + cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) {{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 + 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) {{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 + 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) {{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 + 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) {{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 + cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) {{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 + cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) {{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 + 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) {{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 + cudaError_t cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, cudaStream_t stream) {{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 + 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) {{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 + 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) {{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 + 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) {{endif}} {{if 'cudaMemset' in found_functions}} - cyruntime.cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemset(void* devPtr, int value, size_t count) {{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 + cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) {{endif}} {{if 'cudaMemset3D' in found_functions}} - cyruntime.cudaError_t cudaMemset3D(cyruntime.cudaPitchedPtr pitchedDevPtr, int value, cyruntime.cudaExtent extent) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) {{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 + cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) {{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 + cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) {{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 + cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) {{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 + cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) {{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 + cudaError_t cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) {{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 + cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) {{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 + cudaError_t cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) {{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 + cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) {{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 + cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) {{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 + cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) {{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 + cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) {{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 + 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) {{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 + cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) {{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 + cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) {{endif}} {{if 'cudaMallocAsync' in found_functions}} - cyruntime.cudaError_t cudaMallocAsync(void** devPtr, size_t size, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) {{endif}} {{if 'cudaFreeAsync' in found_functions}} - cyruntime.cudaError_t cudaFreeAsync(void* devPtr, cyruntime.cudaStream_t hStream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) {{endif}} {{if 'cudaMemPoolTrimTo' in found_functions}} - cyruntime.cudaError_t cudaMemPoolTrimTo(cyruntime.cudaMemPool_t memPool, size_t minBytesToKeep) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) {{endif}} {{if 'cudaMemPoolSetAttribute' in found_functions}} - cyruntime.cudaError_t cudaMemPoolSetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) {{endif}} {{if 'cudaMemPoolGetAttribute' in found_functions}} - cyruntime.cudaError_t cudaMemPoolGetAttribute(cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolAttr attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) {{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 + cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) {{endif}} {{if 'cudaMemPoolGetAccess' in found_functions}} - cyruntime.cudaError_t cudaMemPoolGetAccess(cyruntime.cudaMemAccessFlags* flags, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemLocation* location) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) {{endif}} {{if 'cudaMemPoolCreate' in found_functions}} - cyruntime.cudaError_t cudaMemPoolCreate(cyruntime.cudaMemPool_t* memPool, const cyruntime.cudaMemPoolProps* poolProps) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) {{endif}} {{if 'cudaMemPoolDestroy' in found_functions}} - cyruntime.cudaError_t cudaMemPoolDestroy(cyruntime.cudaMemPool_t memPool) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) {{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 + cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) {{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 + cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) {{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 + cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) {{endif}} {{if 'cudaMemPoolExportPointer' in found_functions}} - cyruntime.cudaError_t cudaMemPoolExportPointer(cyruntime.cudaMemPoolPtrExportData* exportData, void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) {{endif}} {{if 'cudaMemPoolImportPointer' in found_functions}} - cyruntime.cudaError_t cudaMemPoolImportPointer(void** ptr, cyruntime.cudaMemPool_t memPool, cyruntime.cudaMemPoolPtrExportData* exportData) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) {{endif}} {{if 'cudaPointerGetAttributes' in found_functions}} - cyruntime.cudaError_t cudaPointerGetAttributes(cyruntime.cudaPointerAttributes* attributes, const void* ptr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) {{endif}} {{if 'cudaDeviceCanAccessPeer' in found_functions}} - cyruntime.cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) {{endif}} {{if 'cudaDeviceEnablePeerAccess' in found_functions}} - cyruntime.cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) {{endif}} {{if 'cudaDeviceDisablePeerAccess' in found_functions}} - cyruntime.cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) {{endif}} {{if 'cudaGraphicsUnregisterResource' in found_functions}} - cyruntime.cudaError_t cudaGraphicsUnregisterResource(cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) {{endif}} {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}} - cyruntime.cudaError_t cudaGraphicsResourceSetMapFlags(cyruntime.cudaGraphicsResource_t resource, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) {{endif}} {{if 'cudaGraphicsMapResources' in found_functions}} - cyruntime.cudaError_t cudaGraphicsMapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) {{endif}} {{if 'cudaGraphicsUnmapResources' in found_functions}} - cyruntime.cudaError_t cudaGraphicsUnmapResources(int count, cyruntime.cudaGraphicsResource_t* resources, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) {{endif}} {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}} - cyruntime.cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) {{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 + cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) {{endif}} {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}} - cyruntime.cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cyruntime.cudaMipmappedArray_t* mipmappedArray, cyruntime.cudaGraphicsResource_t resource) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) {{endif}} {{if 'cudaGetChannelDesc' in found_functions}} - cyruntime.cudaError_t cudaGetChannelDesc(cyruntime.cudaChannelFormatDesc* desc, cyruntime.cudaArray_const_t array) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) {{endif}} {{if 'cudaCreateChannelDesc' in found_functions}} - cyruntime.cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cyruntime.cudaChannelFormatKind f) nogil + cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) {{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 + cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) {{endif}} {{if 'cudaDestroyTextureObject' in found_functions}} - cyruntime.cudaError_t cudaDestroyTextureObject(cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) {{endif}} {{if 'cudaGetTextureObjectResourceDesc' in found_functions}} - cyruntime.cudaError_t cudaGetTextureObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) {{endif}} {{if 'cudaGetTextureObjectTextureDesc' in found_functions}} - cyruntime.cudaError_t cudaGetTextureObjectTextureDesc(cyruntime.cudaTextureDesc* pTexDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) {{endif}} {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}} - cyruntime.cudaError_t cudaGetTextureObjectResourceViewDesc(cyruntime.cudaResourceViewDesc* pResViewDesc, cyruntime.cudaTextureObject_t texObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) {{endif}} {{if 'cudaCreateSurfaceObject' in found_functions}} - cyruntime.cudaError_t cudaCreateSurfaceObject(cyruntime.cudaSurfaceObject_t* pSurfObject, const cyruntime.cudaResourceDesc* pResDesc) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) {{endif}} {{if 'cudaDestroySurfaceObject' in found_functions}} - cyruntime.cudaError_t cudaDestroySurfaceObject(cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) {{endif}} {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}} - cyruntime.cudaError_t cudaGetSurfaceObjectResourceDesc(cyruntime.cudaResourceDesc* pResDesc, cyruntime.cudaSurfaceObject_t surfObject) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) {{endif}} {{if 'cudaDriverGetVersion' in found_functions}} - cyruntime.cudaError_t cudaDriverGetVersion(int* driverVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDriverGetVersion(int* driverVersion) {{endif}} {{if 'cudaRuntimeGetVersion' in found_functions}} - cyruntime.cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) {{endif}} {{if 'cudaGraphCreate' in found_functions}} - cyruntime.cudaError_t cudaGraphCreate(cyruntime.cudaGraph_t* pGraph, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) {{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 + cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) {{endif}} {{if 'cudaGraphKernelNodeGetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphKernelNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) {{endif}} {{if 'cudaGraphKernelNodeSetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphKernelNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaKernelNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) {{endif}} {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}} - cyruntime.cudaError_t cudaGraphKernelNodeCopyAttributes(cyruntime.cudaGraphNode_t hSrc, cyruntime.cudaGraphNode_t hDst) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) {{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 + cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) {{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 + cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) {{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 + cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) {{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 + 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) {{endif}} {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphMemcpyNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) {{endif}} {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphMemcpyNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemcpy3DParms* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) {{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 + cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) {{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 + cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) {{endif}} {{if 'cudaGraphMemsetNodeGetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphMemsetNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) {{endif}} {{if 'cudaGraphMemsetNodeSetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphMemsetNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaMemsetParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) {{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 + cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) {{endif}} {{if 'cudaGraphHostNodeGetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphHostNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) {{endif}} {{if 'cudaGraphHostNodeSetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphHostNodeSetParams(cyruntime.cudaGraphNode_t node, const cyruntime.cudaHostNodeParams* pNodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) {{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 + cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) {{endif}} {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}} - cyruntime.cudaError_t cudaGraphChildGraphNodeGetGraph(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraph_t* pGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) {{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 + cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) {{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 + cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) {{endif}} {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}} - cyruntime.cudaError_t cudaGraphEventRecordNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) {{endif}} {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}} - cyruntime.cudaError_t cudaGraphEventRecordNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) {{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 + cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) {{endif}} {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}} - cyruntime.cudaError_t cudaGraphEventWaitNodeGetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t* event_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) {{endif}} {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}} - cyruntime.cudaError_t cudaGraphEventWaitNodeSetEvent(cyruntime.cudaGraphNode_t node, cyruntime.cudaEvent_t event) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) {{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 + cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) {{endif}} {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreSignalNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) {{endif}} {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) {{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 + cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) {{endif}} {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cyruntime.cudaGraphNode_t hNode, cyruntime.cudaExternalSemaphoreWaitNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) {{endif}} {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cyruntime.cudaGraphNode_t hNode, const cyruntime.cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) {{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 + cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) {{endif}} {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphMemAllocNodeGetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaMemAllocNodeParams* params_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) {{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 + cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) {{endif}} {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphMemFreeNodeGetParams(cyruntime.cudaGraphNode_t node, void* dptr_out) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) {{endif}} {{if 'cudaDeviceGraphMemTrim' in found_functions}} - cyruntime.cudaError_t cudaDeviceGraphMemTrim(int device) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGraphMemTrim(int device) {{endif}} {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}} - cyruntime.cudaError_t cudaDeviceGetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) {{endif}} {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}} - cyruntime.cudaError_t cudaDeviceSetGraphMemAttribute(int device, cyruntime.cudaGraphMemAttributeType attr, void* value) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) {{endif}} {{if 'cudaGraphClone' in found_functions}} - cyruntime.cudaError_t cudaGraphClone(cyruntime.cudaGraph_t* pGraphClone, cyruntime.cudaGraph_t originalGraph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) {{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 + cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) {{endif}} {{if 'cudaGraphNodeGetType' in found_functions}} - cyruntime.cudaError_t cudaGraphNodeGetType(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeType* pType) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) {{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 + cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) {{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 + cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) {{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 + cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) {{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 + cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) {{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 + cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) {{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 + cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) {{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 + cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) {{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 + cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) {{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 + cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) {{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 + cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) {{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 + cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) {{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 + cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) {{endif}} {{if 'cudaGraphDestroyNode' in found_functions}} - cyruntime.cudaError_t cudaGraphDestroyNode(cyruntime.cudaGraphNode_t node) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) {{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 + cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) {{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 + cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) {{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 + cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) {{endif}} {{if 'cudaGraphExecGetFlags' in found_functions}} - cyruntime.cudaError_t cudaGraphExecGetFlags(cyruntime.cudaGraphExec_t graphExec, unsigned long long* flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) {{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 + cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) {{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 + cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) {{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 + cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) {{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 + cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) {{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 + cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) {{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 + cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) {{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 + cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) {{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 + cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) {{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 + cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) {{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 + cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) {{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 + cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) {{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 + cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) {{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 + cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) {{endif}} {{if 'cudaGraphUpload' in found_functions}} - cyruntime.cudaError_t cudaGraphUpload(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) {{endif}} {{if 'cudaGraphLaunch' in found_functions}} - cyruntime.cudaError_t cudaGraphLaunch(cyruntime.cudaGraphExec_t graphExec, cyruntime.cudaStream_t stream) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) {{endif}} {{if 'cudaGraphExecDestroy' in found_functions}} - cyruntime.cudaError_t cudaGraphExecDestroy(cyruntime.cudaGraphExec_t graphExec) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) {{endif}} {{if 'cudaGraphDestroy' in found_functions}} - cyruntime.cudaError_t cudaGraphDestroy(cyruntime.cudaGraph_t graph) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphDestroy(cudaGraph_t graph) {{endif}} {{if 'cudaGraphDebugDotPrint' in found_functions}} - cyruntime.cudaError_t cudaGraphDebugDotPrint(cyruntime.cudaGraph_t graph, const char* path, unsigned int flags) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) {{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 + cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) {{endif}} {{if 'cudaUserObjectRetain' in found_functions}} - cyruntime.cudaError_t cudaUserObjectRetain(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) {{endif}} {{if 'cudaUserObjectRelease' in found_functions}} - cyruntime.cudaError_t cudaUserObjectRelease(cyruntime.cudaUserObject_t object, unsigned int count) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) {{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 + cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) {{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 + cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) {{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 + cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) {{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 + cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) {{endif}} {{if 'cudaGraphNodeSetParams' in found_functions}} - cyruntime.cudaError_t cudaGraphNodeSetParams(cyruntime.cudaGraphNode_t node, cyruntime.cudaGraphNodeParams* nodeParams) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) {{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 + cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) {{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 + cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) {{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 + cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) {{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 + cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) {{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 + cudaError_t cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) {{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 + cudaError_t cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) {{endif}} {{if 'cudaLibraryUnload' in found_functions}} - cyruntime.cudaError_t cudaLibraryUnload(cyruntime.cudaLibrary_t library) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaLibraryUnload(cudaLibrary_t library) {{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 + cudaError_t cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) {{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 + cudaError_t cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) {{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 + cudaError_t cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) {{endif}} {{if 'cudaLibraryGetUnifiedFunction' in found_functions}} - cyruntime.cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cyruntime.cudaLibrary_t library, const char* symbol) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) {{endif}} {{if 'cudaLibraryGetKernelCount' in found_functions}} - cyruntime.cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cyruntime.cudaLibrary_t lib) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) {{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 + cudaError_t cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) {{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 + cudaError_t cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) {{endif}} {{if 'cudaGetExportTable' in found_functions}} - cyruntime.cudaError_t cudaGetExportTable(const void** ppExportTable, const cyruntime.cudaUUID_t* pExportTableId) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) {{endif}} {{if 'cudaGetKernel' in found_functions}} - cyruntime.cudaError_t cudaGetKernel(cyruntime.cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) {{endif}} @@ -1466,30 +3170,30 @@ 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) nogil + cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) {{endif}} {{if 'make_cudaPos' in found_functions}} - cyruntime.cudaPos make_cudaPos(size_t x, size_t y, size_t z) nogil + cudaPos make_cudaPos(size_t x, size_t y, size_t z) {{endif}} {{if 'make_cudaExtent' in found_functions}} - cyruntime.cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) nogil + cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) {{endif}} -cdef extern from "cuda_profiler_api.h": +cdef extern from "cuda_profiler_api.h" nogil: {{if 'cudaProfilerStart' in found_functions}} - cyruntime.cudaError_t cudaProfilerStart() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaProfilerStart() {{endif}} {{if 'cudaProfilerStop' in found_functions}} - cyruntime.cudaError_t cudaProfilerStop() except ?cyruntime.cudaErrorCallRequiresNewerDriver nogil + cudaError_t cudaProfilerStop() {{endif}}