Coverage for cuda / bindings / _bindings / cyruntime.pyx: 36%
1588 statements
« prev ^ index » next coverage.py v7.13.0, created at 2025-12-10 01:19 +0000
1# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
4# This code was automatically generated with version 13.1.0. Do not modify it directly.
5include "../cyruntime_functions.pxi"
7import os
8cimport cuda.bindings._bindings.cyruntime_ptds as ptds
9cimport cython
11cdef bint __cudaPythonInit = False
12cdef bint __usePTDS = False
13cdef int _cudaPythonInit() except -1 nogil:
14 global __cudaPythonInit
15 global __usePTDS
17 with gil:
18 __usePTDS = os.getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=False)
19 __cudaPythonInit = True
20 return __usePTDS
22# Create a very small function to check whether we are init'ed, so the C
23# compiler can inline it.
24cdef inline int cudaPythonInit() except -1 nogil:
25 if __cudaPythonInit:
26 return __usePTDS
27 return _cudaPythonInit()
29cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil:
30 cdef bint usePTDS = cudaPythonInit()
31 if usePTDS:
32 return ptds._cudaDeviceReset()
33 return cudaDeviceReset()
35cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil:
36 cdef bint usePTDS = cudaPythonInit()
37 if usePTDS:
38 return ptds._cudaDeviceSynchronize()
39 return cudaDeviceSynchronize()
41cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil:
42 cdef bint usePTDS = cudaPythonInit()
43 if usePTDS:
44 return ptds._cudaDeviceSetLimit(limit, value)
45 return cudaDeviceSetLimit(limit, value)
47cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil:
48 cdef bint usePTDS = cudaPythonInit()
49 if usePTDS:
50 return ptds._cudaDeviceGetLimit(pValue, limit)
51 return cudaDeviceGetLimit(pValue, limit)
53cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
54 cdef bint usePTDS = cudaPythonInit()
55 if usePTDS:
56 return ptds._cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device)
57 return cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device)
59cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
60 cdef bint usePTDS = cudaPythonInit()
61 if usePTDS:
62 return ptds._cudaDeviceGetCacheConfig(pCacheConfig)
63 return cudaDeviceGetCacheConfig(pCacheConfig)
65cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil:
66 cdef bint usePTDS = cudaPythonInit()
67 if usePTDS:
68 return ptds._cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority)
69 return cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority)
71cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
72 cdef bint usePTDS = cudaPythonInit()
73 if usePTDS:
74 return ptds._cudaDeviceSetCacheConfig(cacheConfig)
75 return cudaDeviceSetCacheConfig(cacheConfig)
77cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil:
78 cdef bint usePTDS = cudaPythonInit()
79 if usePTDS:
80 return ptds._cudaDeviceGetByPCIBusId(device, pciBusId)
81 return cudaDeviceGetByPCIBusId(device, pciBusId)
83cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
84 cdef bint usePTDS = cudaPythonInit()
85 if usePTDS:
86 return ptds._cudaDeviceGetPCIBusId(pciBusId, length, device)
87 return cudaDeviceGetPCIBusId(pciBusId, length, device)
89cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
90 cdef bint usePTDS = cudaPythonInit()
91 if usePTDS:
92 return ptds._cudaIpcGetEventHandle(handle, event)
93 return cudaIpcGetEventHandle(handle, event)
95cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil:
96 cdef bint usePTDS = cudaPythonInit()
97 if usePTDS:
98 return ptds._cudaIpcOpenEventHandle(event, handle)
99 return cudaIpcOpenEventHandle(event, handle)
101cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
102 cdef bint usePTDS = cudaPythonInit()
103 if usePTDS:
104 return ptds._cudaIpcGetMemHandle(handle, devPtr)
105 return cudaIpcGetMemHandle(handle, devPtr)
107cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
108 cdef bint usePTDS = cudaPythonInit()
109 if usePTDS:
110 return ptds._cudaIpcOpenMemHandle(devPtr, handle, flags)
111 return cudaIpcOpenMemHandle(devPtr, handle, flags)
113cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
114 cdef bint usePTDS = cudaPythonInit()
115 if usePTDS:
116 return ptds._cudaIpcCloseMemHandle(devPtr)
117 return cudaIpcCloseMemHandle(devPtr)
119cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil:
120 cdef bint usePTDS = cudaPythonInit()
121 if usePTDS:
122 return ptds._cudaDeviceFlushGPUDirectRDMAWrites(target, scope)
123 return cudaDeviceFlushGPUDirectRDMAWrites(target, scope)
125cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil:
126 cdef bint usePTDS = cudaPythonInit()
127 if usePTDS:
128 return ptds._cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback)
129 return cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback)
131cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil:
132 cdef bint usePTDS = cudaPythonInit()
133 if usePTDS:
134 return ptds._cudaDeviceUnregisterAsyncNotification(device, callback)
135 return cudaDeviceUnregisterAsyncNotification(device, callback)
137cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
138 cdef bint usePTDS = cudaPythonInit()
139 if usePTDS:
140 return ptds._cudaDeviceGetSharedMemConfig(pConfig)
141 return cudaDeviceGetSharedMemConfig(pConfig)
143cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
144 cdef bint usePTDS = cudaPythonInit()
145 if usePTDS:
146 return ptds._cudaDeviceSetSharedMemConfig(config)
147 return cudaDeviceSetSharedMemConfig(config)
149cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
150 cdef bint usePTDS = cudaPythonInit()
151 if usePTDS:
152 return ptds._cudaGetLastError()
153 return cudaGetLastError()
155cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
156 cdef bint usePTDS = cudaPythonInit()
157 if usePTDS:
158 return ptds._cudaPeekAtLastError()
159 return cudaPeekAtLastError()
161cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil:
162 cdef bint usePTDS = cudaPythonInit()
163 if usePTDS:
164 return ptds._cudaGetErrorName(error)
165 return cudaGetErrorName(error)
167cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil:
168 cdef bint usePTDS = cudaPythonInit()
169 if usePTDS:
170 return ptds._cudaGetErrorString(error)
171 return cudaGetErrorString(error)
173cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil:
174 cdef bint usePTDS = cudaPythonInit()
175 if usePTDS:
176 return ptds._cudaGetDeviceCount(count)
177 return cudaGetDeviceCount(count)
179cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
180 cdef bint usePTDS = cudaPythonInit()
181 if usePTDS:
182 return ptds._cudaGetDeviceProperties(prop, device)
183 return cudaGetDeviceProperties(prop, device)
185cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
186 cdef bint usePTDS = cudaPythonInit()
187 if usePTDS:
188 return ptds._cudaDeviceGetAttribute(value, attr, device)
189 return cudaDeviceGetAttribute(value, attr, device)
191cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
192 cdef bint usePTDS = cudaPythonInit()
193 if usePTDS:
194 return ptds._cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device)
195 return cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device)
197cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
198 cdef bint usePTDS = cudaPythonInit()
199 if usePTDS:
200 return ptds._cudaDeviceGetDefaultMemPool(memPool, device)
201 return cudaDeviceGetDefaultMemPool(memPool, device)
203cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
204 cdef bint usePTDS = cudaPythonInit()
205 if usePTDS:
206 return ptds._cudaDeviceSetMemPool(device, memPool)
207 return cudaDeviceSetMemPool(device, memPool)
209cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
210 cdef bint usePTDS = cudaPythonInit()
211 if usePTDS:
212 return ptds._cudaDeviceGetMemPool(memPool, device)
213 return cudaDeviceGetMemPool(memPool, device)
215cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
216 cdef bint usePTDS = cudaPythonInit()
217 if usePTDS:
218 return ptds._cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags)
219 return cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags)
221cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
222 cdef bint usePTDS = cudaPythonInit()
223 if usePTDS:
224 return ptds._cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice)
225 return cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice)
227cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
228 cdef bint usePTDS = cudaPythonInit()
229 if usePTDS:
230 return ptds._cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice)
231 return cudaDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDevice, dstDevice)
233cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil:
234 cdef bint usePTDS = cudaPythonInit()
235 if usePTDS:
236 return ptds._cudaChooseDevice(device, prop)
237 return cudaChooseDevice(device, prop)
239cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
240 cdef bint usePTDS = cudaPythonInit()
241 if usePTDS:
242 return ptds._cudaInitDevice(device, deviceFlags, flags)
243 return cudaInitDevice(device, deviceFlags, flags)
245cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil:
246 cdef bint usePTDS = cudaPythonInit()
247 if usePTDS:
248 return ptds._cudaSetDevice(device)
249 return cudaSetDevice(device)
251cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil:
252 cdef bint usePTDS = cudaPythonInit()
253 if usePTDS:
254 return ptds._cudaGetDevice(device)
255 return cudaGetDevice(device)
257cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
258 cdef bint usePTDS = cudaPythonInit()
259 if usePTDS:
260 return ptds._cudaSetDeviceFlags(flags)
261 return cudaSetDeviceFlags(flags)
263cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
264 cdef bint usePTDS = cudaPythonInit()
265 if usePTDS:
266 return ptds._cudaGetDeviceFlags(flags)
267 return cudaGetDeviceFlags(flags)
269cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
270 cdef bint usePTDS = cudaPythonInit()
271 if usePTDS:
272 return ptds._cudaStreamCreate(pStream)
273 return cudaStreamCreate(pStream)
275cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
276 cdef bint usePTDS = cudaPythonInit()
277 if usePTDS:
278 return ptds._cudaStreamCreateWithFlags(pStream, flags)
279 return cudaStreamCreateWithFlags(pStream, flags)
281cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil:
282 cdef bint usePTDS = cudaPythonInit()
283 if usePTDS:
284 return ptds._cudaStreamCreateWithPriority(pStream, flags, priority)
285 return cudaStreamCreateWithPriority(pStream, flags, priority)
287cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil:
288 cdef bint usePTDS = cudaPythonInit()
289 if usePTDS:
290 return ptds._cudaStreamGetPriority(hStream, priority)
291 return cudaStreamGetPriority(hStream, priority)
293cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
294 cdef bint usePTDS = cudaPythonInit()
295 if usePTDS:
296 return ptds._cudaStreamGetFlags(hStream, flags)
297 return cudaStreamGetFlags(hStream, flags)
299cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil:
300 cdef bint usePTDS = cudaPythonInit()
301 if usePTDS:
302 return ptds._cudaStreamGetId(hStream, streamId)
303 return cudaStreamGetId(hStream, streamId)
305cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil:
306 cdef bint usePTDS = cudaPythonInit()
307 if usePTDS:
308 return ptds._cudaStreamGetDevice(hStream, device)
309 return cudaStreamGetDevice(hStream, device)
311cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil:
312 cdef bint usePTDS = cudaPythonInit()
313 if usePTDS:
314 return ptds._cudaCtxResetPersistingL2Cache()
315 return cudaCtxResetPersistingL2Cache()
317cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil:
318 cdef bint usePTDS = cudaPythonInit()
319 if usePTDS:
320 return ptds._cudaStreamCopyAttributes(dst, src)
321 return cudaStreamCopyAttributes(dst, src)
323cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
324 cdef bint usePTDS = cudaPythonInit()
325 if usePTDS:
326 return ptds._cudaStreamGetAttribute(hStream, attr, value_out)
327 return cudaStreamGetAttribute(hStream, attr, value_out)
329cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
330 cdef bint usePTDS = cudaPythonInit()
331 if usePTDS:
332 return ptds._cudaStreamSetAttribute(hStream, attr, value)
333 return cudaStreamSetAttribute(hStream, attr, value)
335cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
336 cdef bint usePTDS = cudaPythonInit()
337 if usePTDS:
338 return ptds._cudaStreamDestroy(stream)
339 return cudaStreamDestroy(stream)
341cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
342 cdef bint usePTDS = cudaPythonInit()
343 if usePTDS:
344 return ptds._cudaStreamWaitEvent(stream, event, flags)
345 return cudaStreamWaitEvent(stream, event, flags)
347cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
348 cdef bint usePTDS = cudaPythonInit()
349 if usePTDS:
350 return ptds._cudaStreamAddCallback(stream, callback, userData, flags)
351 return cudaStreamAddCallback(stream, callback, userData, flags)
353cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
354 cdef bint usePTDS = cudaPythonInit()
355 if usePTDS:
356 return ptds._cudaStreamSynchronize(stream)
357 return cudaStreamSynchronize(stream)
359cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
360 cdef bint usePTDS = cudaPythonInit()
361 if usePTDS:
362 return ptds._cudaStreamQuery(stream)
363 return cudaStreamQuery(stream)
365cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
366 cdef bint usePTDS = cudaPythonInit()
367 if usePTDS:
368 return ptds._cudaStreamAttachMemAsync(stream, devPtr, length, flags)
369 return cudaStreamAttachMemAsync(stream, devPtr, length, flags)
371cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil:
372 cdef bint usePTDS = cudaPythonInit()
373 if usePTDS:
374 return ptds._cudaStreamBeginCapture(stream, mode)
375 return cudaStreamBeginCapture(stream, mode)
377cdef cudaError_t _cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil:
378 cdef bint usePTDS = cudaPythonInit()
379 if usePTDS:
380 return ptds._cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode)
381 return cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode)
383cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil:
384 cdef bint usePTDS = cudaPythonInit()
385 if usePTDS:
386 return ptds._cudaThreadExchangeStreamCaptureMode(mode)
387 return cudaThreadExchangeStreamCaptureMode(mode)
389cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
390 cdef bint usePTDS = cudaPythonInit()
391 if usePTDS:
392 return ptds._cudaStreamEndCapture(stream, pGraph)
393 return cudaStreamEndCapture(stream, pGraph)
395cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
396 cdef bint usePTDS = cudaPythonInit()
397 if usePTDS:
398 return ptds._cudaStreamIsCapturing(stream, pCaptureStatus)
399 return cudaStreamIsCapturing(stream, pCaptureStatus)
401cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil:
402 cdef bint usePTDS = cudaPythonInit()
403 if usePTDS:
404 return ptds._cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out)
405 return cudaStreamGetCaptureInfo(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out)
407cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
408 cdef bint usePTDS = cudaPythonInit()
409 if usePTDS:
410 return ptds._cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags)
411 return cudaStreamUpdateCaptureDependencies(stream, dependencies, dependencyData, numDependencies, flags)
413cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil:
414 cdef bint usePTDS = cudaPythonInit()
415 if usePTDS:
416 return ptds._cudaEventCreate(event)
417 return cudaEventCreate(event)
419cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
420 cdef bint usePTDS = cudaPythonInit()
421 if usePTDS:
422 return ptds._cudaEventCreateWithFlags(event, flags)
423 return cudaEventCreateWithFlags(event, flags)
425cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
426 cdef bint usePTDS = cudaPythonInit()
427 if usePTDS:
428 return ptds._cudaEventRecord(event, stream)
429 return cudaEventRecord(event, stream)
431cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
432 cdef bint usePTDS = cudaPythonInit()
433 if usePTDS:
434 return ptds._cudaEventRecordWithFlags(event, stream, flags)
435 return cudaEventRecordWithFlags(event, stream, flags)
437cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
438 cdef bint usePTDS = cudaPythonInit()
439 if usePTDS:
440 return ptds._cudaEventQuery(event)
441 return cudaEventQuery(event)
443cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
444 cdef bint usePTDS = cudaPythonInit()
445 if usePTDS:
446 return ptds._cudaEventSynchronize(event)
447 return cudaEventSynchronize(event)
449cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
450 cdef bint usePTDS = cudaPythonInit()
451 if usePTDS:
452 return ptds._cudaEventDestroy(event)
453 return cudaEventDestroy(event)
455cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil:
456 cdef bint usePTDS = cudaPythonInit()
457 if usePTDS:
458 return ptds._cudaEventElapsedTime(ms, start, end)
459 return cudaEventElapsedTime(ms, start, end)
461cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
462 cdef bint usePTDS = cudaPythonInit()
463 if usePTDS:
464 return ptds._cudaImportExternalMemory(extMem_out, memHandleDesc)
465 return cudaImportExternalMemory(extMem_out, memHandleDesc)
467cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
468 cdef bint usePTDS = cudaPythonInit()
469 if usePTDS:
470 return ptds._cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc)
471 return cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc)
473cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
474 cdef bint usePTDS = cudaPythonInit()
475 if usePTDS:
476 return ptds._cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc)
477 return cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc)
479cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil:
480 cdef bint usePTDS = cudaPythonInit()
481 if usePTDS:
482 return ptds._cudaDestroyExternalMemory(extMem)
483 return cudaDestroyExternalMemory(extMem)
485cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
486 cdef bint usePTDS = cudaPythonInit()
487 if usePTDS:
488 return ptds._cudaImportExternalSemaphore(extSem_out, semHandleDesc)
489 return cudaImportExternalSemaphore(extSem_out, semHandleDesc)
491cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
492 cdef bint usePTDS = cudaPythonInit()
493 if usePTDS:
494 return ptds._cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
495 return cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
497cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
498 cdef bint usePTDS = cudaPythonInit()
499 if usePTDS:
500 return ptds._cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
501 return cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
503cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil:
504 cdef bint usePTDS = cudaPythonInit()
505 if usePTDS:
506 return ptds._cudaDestroyExternalSemaphore(extSem)
507 return cudaDestroyExternalSemaphore(extSem)
509cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
510 cdef bint usePTDS = cudaPythonInit()
511 if usePTDS:
512 return ptds._cudaFuncSetCacheConfig(func, cacheConfig)
513 return cudaFuncSetCacheConfig(func, cacheConfig)
515cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil:
516 cdef bint usePTDS = cudaPythonInit()
517 if usePTDS:
518 return ptds._cudaFuncGetAttributes(attr, func)
519 return cudaFuncGetAttributes(attr, func)
521cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil:
522 cdef bint usePTDS = cudaPythonInit()
523 if usePTDS:
524 return ptds._cudaFuncSetAttribute(func, attr, value)
525 return cudaFuncSetAttribute(func, attr, value)
527cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil:
528 cdef bint usePTDS = cudaPythonInit()
529 if usePTDS:
530 return ptds._cudaLaunchHostFunc(stream, fn, userData)
531 return cudaLaunchHostFunc(stream, fn, userData)
533cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
534 cdef bint usePTDS = cudaPythonInit()
535 if usePTDS:
536 return ptds._cudaFuncSetSharedMemConfig(func, config)
537 return cudaFuncSetSharedMemConfig(func, config)
539cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil:
540 cdef bint usePTDS = cudaPythonInit()
541 if usePTDS:
542 return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize)
543 return cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize)
545cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil:
546 cdef bint usePTDS = cudaPythonInit()
547 if usePTDS:
548 return ptds._cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize)
549 return cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize)
551cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
552 cdef bint usePTDS = cudaPythonInit()
553 if usePTDS:
554 return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags)
555 return cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags)
557cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
558 cdef bint usePTDS = cudaPythonInit()
559 if usePTDS:
560 return ptds._cudaMallocManaged(devPtr, size, flags)
561 return cudaMallocManaged(devPtr, size, flags)
563cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
564 cdef bint usePTDS = cudaPythonInit()
565 if usePTDS:
566 return ptds._cudaMalloc(devPtr, size)
567 return cudaMalloc(devPtr, size)
569cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
570 cdef bint usePTDS = cudaPythonInit()
571 if usePTDS:
572 return ptds._cudaMallocHost(ptr, size)
573 return cudaMallocHost(ptr, size)
575cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
576 cdef bint usePTDS = cudaPythonInit()
577 if usePTDS:
578 return ptds._cudaMallocPitch(devPtr, pitch, width, height)
579 return cudaMallocPitch(devPtr, pitch, width, height)
581cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
582 cdef bint usePTDS = cudaPythonInit()
583 if usePTDS:
584 return ptds._cudaMallocArray(array, desc, width, height, flags)
585 return cudaMallocArray(array, desc, width, height, flags)
587cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
588 cdef bint usePTDS = cudaPythonInit()
589 if usePTDS:
590 return ptds._cudaFree(devPtr)
591 return cudaFree(devPtr)
593cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
594 cdef bint usePTDS = cudaPythonInit()
595 if usePTDS:
596 return ptds._cudaFreeHost(ptr)
597 return cudaFreeHost(ptr)
599cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
600 cdef bint usePTDS = cudaPythonInit()
601 if usePTDS:
602 return ptds._cudaFreeArray(array)
603 return cudaFreeArray(array)
605cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil:
606 cdef bint usePTDS = cudaPythonInit()
607 if usePTDS:
608 return ptds._cudaFreeMipmappedArray(mipmappedArray)
609 return cudaFreeMipmappedArray(mipmappedArray)
611cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
612 cdef bint usePTDS = cudaPythonInit()
613 if usePTDS:
614 return ptds._cudaHostAlloc(pHost, size, flags)
615 return cudaHostAlloc(pHost, size, flags)
617cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
618 cdef bint usePTDS = cudaPythonInit()
619 if usePTDS:
620 return ptds._cudaHostRegister(ptr, size, flags)
621 return cudaHostRegister(ptr, size, flags)
623cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
624 cdef bint usePTDS = cudaPythonInit()
625 if usePTDS:
626 return ptds._cudaHostUnregister(ptr)
627 return cudaHostUnregister(ptr)
629cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
630 cdef bint usePTDS = cudaPythonInit()
631 if usePTDS:
632 return ptds._cudaHostGetDevicePointer(pDevice, pHost, flags)
633 return cudaHostGetDevicePointer(pDevice, pHost, flags)
635cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil:
636 cdef bint usePTDS = cudaPythonInit()
637 if usePTDS:
638 return ptds._cudaHostGetFlags(pFlags, pHost)
639 return cudaHostGetFlags(pFlags, pHost)
641cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
642 cdef bint usePTDS = cudaPythonInit()
643 if usePTDS:
644 return ptds._cudaMalloc3D(pitchedDevPtr, extent)
645 return cudaMalloc3D(pitchedDevPtr, extent)
647cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
648 cdef bint usePTDS = cudaPythonInit()
649 if usePTDS:
650 return ptds._cudaMalloc3DArray(array, desc, extent, flags)
651 return cudaMalloc3DArray(array, desc, extent, flags)
653cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
654 cdef bint usePTDS = cudaPythonInit()
655 if usePTDS:
656 return ptds._cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags)
657 return cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags)
659cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil:
660 cdef bint usePTDS = cudaPythonInit()
661 if usePTDS:
662 return ptds._cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level)
663 return cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level)
665cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
666 cdef bint usePTDS = cudaPythonInit()
667 if usePTDS:
668 return ptds._cudaMemcpy3D(p)
669 return cudaMemcpy3D(p)
671cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
672 cdef bint usePTDS = cudaPythonInit()
673 if usePTDS:
674 return ptds._cudaMemcpy3DPeer(p)
675 return cudaMemcpy3DPeer(p)
677cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
678 cdef bint usePTDS = cudaPythonInit()
679 if usePTDS:
680 return ptds._cudaMemcpy3DAsync(p, stream)
681 return cudaMemcpy3DAsync(p, stream)
683cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
684 cdef bint usePTDS = cudaPythonInit()
685 if usePTDS:
686 return ptds._cudaMemcpy3DPeerAsync(p, stream)
687 return cudaMemcpy3DPeerAsync(p, stream)
689cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil:
690 cdef bint usePTDS = cudaPythonInit()
691 if usePTDS:
692 return ptds._cudaMemGetInfo(free, total)
693 return cudaMemGetInfo(free, total)
695cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
696 cdef bint usePTDS = cudaPythonInit()
697 if usePTDS:
698 return ptds._cudaArrayGetInfo(desc, extent, flags, array)
699 return cudaArrayGetInfo(desc, extent, flags, array)
701cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil:
702 cdef bint usePTDS = cudaPythonInit()
703 if usePTDS:
704 return ptds._cudaArrayGetPlane(pPlaneArray, hArray, planeIdx)
705 return cudaArrayGetPlane(pPlaneArray, hArray, planeIdx)
707cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
708 cdef bint usePTDS = cudaPythonInit()
709 if usePTDS:
710 return ptds._cudaArrayGetMemoryRequirements(memoryRequirements, array, device)
711 return cudaArrayGetMemoryRequirements(memoryRequirements, array, device)
713cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
714 cdef bint usePTDS = cudaPythonInit()
715 if usePTDS:
716 return ptds._cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device)
717 return cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device)
719cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
720 cdef bint usePTDS = cudaPythonInit()
721 if usePTDS:
722 return ptds._cudaArrayGetSparseProperties(sparseProperties, array)
723 return cudaArrayGetSparseProperties(sparseProperties, array)
725cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil:
726 cdef bint usePTDS = cudaPythonInit()
727 if usePTDS:
728 return ptds._cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap)
729 return cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap)
731cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
732 cdef bint usePTDS = cudaPythonInit()
733 if usePTDS:
734 return ptds._cudaMemcpy(dst, src, count, kind)
735 return cudaMemcpy(dst, src, count, kind)
737cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
738 cdef bint usePTDS = cudaPythonInit()
739 if usePTDS:
740 return ptds._cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count)
741 return cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count)
743cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
744 cdef bint usePTDS = cudaPythonInit()
745 if usePTDS:
746 return ptds._cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind)
747 return cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind)
749cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
750 cdef bint usePTDS = cudaPythonInit()
751 if usePTDS:
752 return ptds._cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind)
753 return cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind)
755cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
756 cdef bint usePTDS = cudaPythonInit()
757 if usePTDS:
758 return ptds._cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind)
759 return cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind)
761cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
762 cdef bint usePTDS = cudaPythonInit()
763 if usePTDS:
764 return ptds._cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind)
765 return cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind)
767cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
768 cdef bint usePTDS = cudaPythonInit()
769 if usePTDS:
770 return ptds._cudaMemcpyAsync(dst, src, count, kind, stream)
771 return cudaMemcpyAsync(dst, src, count, kind, stream)
773cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
774 cdef bint usePTDS = cudaPythonInit()
775 if usePTDS:
776 return ptds._cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream)
777 return cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream)
779cdef cudaError_t _cudaMemcpyBatchAsync(const void** dsts, const void** srcs, const size_t* sizes, size_t count, cudaMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
780 cdef bint usePTDS = cudaPythonInit()
781 if usePTDS:
782 return ptds._cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream)
783 return cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream)
785cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
786 cdef bint usePTDS = cudaPythonInit()
787 if usePTDS:
788 return ptds._cudaMemcpy3DBatchAsync(numOps, opList, flags, stream)
789 return cudaMemcpy3DBatchAsync(numOps, opList, flags, stream)
791cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
792 cdef bint usePTDS = cudaPythonInit()
793 if usePTDS:
794 return ptds._cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream)
795 return cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream)
797cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
798 cdef bint usePTDS = cudaPythonInit()
799 if usePTDS:
800 return ptds._cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream)
801 return cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream)
803cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
804 cdef bint usePTDS = cudaPythonInit()
805 if usePTDS:
806 return ptds._cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream)
807 return cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream)
809cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
810 cdef bint usePTDS = cudaPythonInit()
811 if usePTDS:
812 return ptds._cudaMemset(devPtr, value, count)
813 return cudaMemset(devPtr, value, count)
815cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
816 cdef bint usePTDS = cudaPythonInit()
817 if usePTDS:
818 return ptds._cudaMemset2D(devPtr, pitch, value, width, height)
819 return cudaMemset2D(devPtr, pitch, value, width, height)
821cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
822 cdef bint usePTDS = cudaPythonInit()
823 if usePTDS:
824 return ptds._cudaMemset3D(pitchedDevPtr, value, extent)
825 return cudaMemset3D(pitchedDevPtr, value, extent)
827cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
828 cdef bint usePTDS = cudaPythonInit()
829 if usePTDS:
830 return ptds._cudaMemsetAsync(devPtr, value, count, stream)
831 return cudaMemsetAsync(devPtr, value, count, stream)
833cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
834 cdef bint usePTDS = cudaPythonInit()
835 if usePTDS:
836 return ptds._cudaMemset2DAsync(devPtr, pitch, value, width, height, stream)
837 return cudaMemset2DAsync(devPtr, pitch, value, width, height, stream)
839cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
840 cdef bint usePTDS = cudaPythonInit()
841 if usePTDS:
842 return ptds._cudaMemset3DAsync(pitchedDevPtr, value, extent, stream)
843 return cudaMemset3DAsync(pitchedDevPtr, value, extent, stream)
845cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
846 cdef bint usePTDS = cudaPythonInit()
847 if usePTDS:
848 return ptds._cudaMemPrefetchAsync(devPtr, count, location, flags, stream)
849 return cudaMemPrefetchAsync(devPtr, count, location, flags, stream)
851cdef cudaError_t _cudaMemPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
852 cdef bint usePTDS = cudaPythonInit()
853 if usePTDS:
854 return ptds._cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream)
855 return cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream)
857cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
858 cdef bint usePTDS = cudaPythonInit()
859 if usePTDS:
860 return ptds._cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream)
861 return cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream)
863cdef cudaError_t _cudaMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, cudaMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
864 cdef bint usePTDS = cudaPythonInit()
865 if usePTDS:
866 return ptds._cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream)
867 return cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream)
869cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil:
870 cdef bint usePTDS = cudaPythonInit()
871 if usePTDS:
872 return ptds._cudaMemAdvise(devPtr, count, advice, location)
873 return cudaMemAdvise(devPtr, count, advice, location)
875cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
876 cdef bint usePTDS = cudaPythonInit()
877 if usePTDS:
878 return ptds._cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count)
879 return cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count)
881cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
882 cdef bint usePTDS = cudaPythonInit()
883 if usePTDS:
884 return ptds._cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count)
885 return cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count)
887cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
888 cdef bint usePTDS = cudaPythonInit()
889 if usePTDS:
890 return ptds._cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind)
891 return cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind)
893cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
894 cdef bint usePTDS = cudaPythonInit()
895 if usePTDS:
896 return ptds._cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind)
897 return cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind)
899cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
900 cdef bint usePTDS = cudaPythonInit()
901 if usePTDS:
902 return ptds._cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind)
903 return cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind)
905cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
906 cdef bint usePTDS = cudaPythonInit()
907 if usePTDS:
908 return ptds._cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream)
909 return cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream)
911cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
912 cdef bint usePTDS = cudaPythonInit()
913 if usePTDS:
914 return ptds._cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream)
915 return cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream)
917cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
918 cdef bint usePTDS = cudaPythonInit()
919 if usePTDS:
920 return ptds._cudaMallocAsync(devPtr, size, hStream)
921 return cudaMallocAsync(devPtr, size, hStream)
923cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
924 cdef bint usePTDS = cudaPythonInit()
925 if usePTDS:
926 return ptds._cudaFreeAsync(devPtr, hStream)
927 return cudaFreeAsync(devPtr, hStream)
929cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil:
930 cdef bint usePTDS = cudaPythonInit()
931 if usePTDS:
932 return ptds._cudaMemPoolTrimTo(memPool, minBytesToKeep)
933 return cudaMemPoolTrimTo(memPool, minBytesToKeep)
935cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
936 cdef bint usePTDS = cudaPythonInit()
937 if usePTDS:
938 return ptds._cudaMemPoolSetAttribute(memPool, attr, value)
939 return cudaMemPoolSetAttribute(memPool, attr, value)
941cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
942 cdef bint usePTDS = cudaPythonInit()
943 if usePTDS:
944 return ptds._cudaMemPoolGetAttribute(memPool, attr, value)
945 return cudaMemPoolGetAttribute(memPool, attr, value)
947cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
948 cdef bint usePTDS = cudaPythonInit()
949 if usePTDS:
950 return ptds._cudaMemPoolSetAccess(memPool, descList, count)
951 return cudaMemPoolSetAccess(memPool, descList, count)
953cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil:
954 cdef bint usePTDS = cudaPythonInit()
955 if usePTDS:
956 return ptds._cudaMemPoolGetAccess(flags, memPool, location)
957 return cudaMemPoolGetAccess(flags, memPool, location)
959cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil:
960 cdef bint usePTDS = cudaPythonInit()
961 if usePTDS:
962 return ptds._cudaMemPoolCreate(memPool, poolProps)
963 return cudaMemPoolCreate(memPool, poolProps)
965cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
966 cdef bint usePTDS = cudaPythonInit()
967 if usePTDS:
968 return ptds._cudaMemPoolDestroy(memPool)
969 return cudaMemPoolDestroy(memPool)
971cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil:
972 cdef bint usePTDS = cudaPythonInit()
973 if usePTDS:
974 return ptds._cudaMemGetDefaultMemPool(memPool, location, typename)
975 return cudaMemGetDefaultMemPool(memPool, location, typename)
977cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil:
978 cdef bint usePTDS = cudaPythonInit()
979 if usePTDS:
980 return ptds._cudaMemGetMemPool(memPool, location, typename)
981 return cudaMemGetMemPool(memPool, location, typename)
983cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
984 cdef bint usePTDS = cudaPythonInit()
985 if usePTDS:
986 return ptds._cudaMemSetMemPool(location, typename, memPool)
987 return cudaMemSetMemPool(location, typename, memPool)
989cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
990 cdef bint usePTDS = cudaPythonInit()
991 if usePTDS:
992 return ptds._cudaMallocFromPoolAsync(ptr, size, memPool, stream)
993 return cudaMallocFromPoolAsync(ptr, size, memPool, stream)
995cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
996 cdef bint usePTDS = cudaPythonInit()
997 if usePTDS:
998 return ptds._cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags)
999 return cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags)
1001cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1002 cdef bint usePTDS = cudaPythonInit()
1003 if usePTDS:
1004 return ptds._cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags)
1005 return cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags)
1007cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
1008 cdef bint usePTDS = cudaPythonInit()
1009 if usePTDS:
1010 return ptds._cudaMemPoolExportPointer(exportData, ptr)
1011 return cudaMemPoolExportPointer(exportData, ptr)
1013cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil:
1014 cdef bint usePTDS = cudaPythonInit()
1015 if usePTDS:
1016 return ptds._cudaMemPoolImportPointer(ptr, memPool, exportData)
1017 return cudaMemPoolImportPointer(ptr, memPool, exportData)
1019cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
1020 cdef bint usePTDS = cudaPythonInit()
1021 if usePTDS:
1022 return ptds._cudaPointerGetAttributes(attributes, ptr)
1023 return cudaPointerGetAttributes(attributes, ptr)
1025cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
1026 cdef bint usePTDS = cudaPythonInit()
1027 if usePTDS:
1028 return ptds._cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice)
1029 return cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice)
1031cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1032 cdef bint usePTDS = cudaPythonInit()
1033 if usePTDS:
1034 return ptds._cudaDeviceEnablePeerAccess(peerDevice, flags)
1035 return cudaDeviceEnablePeerAccess(peerDevice, flags)
1037cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
1038 cdef bint usePTDS = cudaPythonInit()
1039 if usePTDS:
1040 return ptds._cudaDeviceDisablePeerAccess(peerDevice)
1041 return cudaDeviceDisablePeerAccess(peerDevice)
1043cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
1044 cdef bint usePTDS = cudaPythonInit()
1045 if usePTDS:
1046 return ptds._cudaGraphicsUnregisterResource(resource)
1047 return cudaGraphicsUnregisterResource(resource)
1049cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1050 cdef bint usePTDS = cudaPythonInit()
1051 if usePTDS:
1052 return ptds._cudaGraphicsResourceSetMapFlags(resource, flags)
1053 return cudaGraphicsResourceSetMapFlags(resource, flags)
1055cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
1056 cdef bint usePTDS = cudaPythonInit()
1057 if usePTDS:
1058 return ptds._cudaGraphicsMapResources(count, resources, stream)
1059 return cudaGraphicsMapResources(count, resources, stream)
1061cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
1062 cdef bint usePTDS = cudaPythonInit()
1063 if usePTDS:
1064 return ptds._cudaGraphicsUnmapResources(count, resources, stream)
1065 return cudaGraphicsUnmapResources(count, resources, stream)
1067cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
1068 cdef bint usePTDS = cudaPythonInit()
1069 if usePTDS:
1070 return ptds._cudaGraphicsResourceGetMappedPointer(devPtr, size, resource)
1071 return cudaGraphicsResourceGetMappedPointer(devPtr, size, resource)
1073cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
1074 cdef bint usePTDS = cudaPythonInit()
1075 if usePTDS:
1076 return ptds._cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel)
1077 return cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel)
1079cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
1080 cdef bint usePTDS = cudaPythonInit()
1081 if usePTDS:
1082 return ptds._cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource)
1083 return cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource)
1085cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
1086 cdef bint usePTDS = cudaPythonInit()
1087 if usePTDS:
1088 return ptds._cudaGetChannelDesc(desc, array)
1089 return cudaGetChannelDesc(desc, array)
1090@cython.show_performance_hints(False)
1091cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil:
1092 cdef bint usePTDS = cudaPythonInit()
1093 if usePTDS:
1094 return ptds._cudaCreateChannelDesc(x, y, z, w, f)
1095 return cudaCreateChannelDesc(x, y, z, w, f)
1097cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
1098 cdef bint usePTDS = cudaPythonInit()
1099 if usePTDS:
1100 return ptds._cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc)
1101 return cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc)
1103cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
1104 cdef bint usePTDS = cudaPythonInit()
1105 if usePTDS:
1106 return ptds._cudaDestroyTextureObject(texObject)
1107 return cudaDestroyTextureObject(texObject)
1109cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
1110 cdef bint usePTDS = cudaPythonInit()
1111 if usePTDS:
1112 return ptds._cudaGetTextureObjectResourceDesc(pResDesc, texObject)
1113 return cudaGetTextureObjectResourceDesc(pResDesc, texObject)
1115cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
1116 cdef bint usePTDS = cudaPythonInit()
1117 if usePTDS:
1118 return ptds._cudaGetTextureObjectTextureDesc(pTexDesc, texObject)
1119 return cudaGetTextureObjectTextureDesc(pTexDesc, texObject)
1121cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
1122 cdef bint usePTDS = cudaPythonInit()
1123 if usePTDS:
1124 return ptds._cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject)
1125 return cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject)
1127cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
1128 cdef bint usePTDS = cudaPythonInit()
1129 if usePTDS:
1130 return ptds._cudaCreateSurfaceObject(pSurfObject, pResDesc)
1131 return cudaCreateSurfaceObject(pSurfObject, pResDesc)
1133cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
1134 cdef bint usePTDS = cudaPythonInit()
1135 if usePTDS:
1136 return ptds._cudaDestroySurfaceObject(surfObject)
1137 return cudaDestroySurfaceObject(surfObject)
1139cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
1140 cdef bint usePTDS = cudaPythonInit()
1141 if usePTDS:
1142 return ptds._cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject)
1143 return cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject)
1145cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
1146 cdef bint usePTDS = cudaPythonInit()
1147 if usePTDS:
1148 return ptds._cudaDriverGetVersion(driverVersion)
1149 return cudaDriverGetVersion(driverVersion)
1151cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
1152 cdef bint usePTDS = cudaPythonInit()
1153 if usePTDS:
1154 return ptds._cudaRuntimeGetVersion(runtimeVersion)
1155 return cudaRuntimeGetVersion(runtimeVersion)
1157cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil:
1158 cdef bint usePTDS = cudaPythonInit()
1159 if usePTDS:
1160 return ptds._cudaLogsRegisterCallback(callbackFunc, userData, callback_out)
1161 return cudaLogsRegisterCallback(callbackFunc, userData, callback_out)
1163cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil:
1164 cdef bint usePTDS = cudaPythonInit()
1165 if usePTDS:
1166 return ptds._cudaLogsUnregisterCallback(callback)
1167 return cudaLogsUnregisterCallback(callback)
1169cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1170 cdef bint usePTDS = cudaPythonInit()
1171 if usePTDS:
1172 return ptds._cudaLogsCurrent(iterator_out, flags)
1173 return cudaLogsCurrent(iterator_out, flags)
1175cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1176 cdef bint usePTDS = cudaPythonInit()
1177 if usePTDS:
1178 return ptds._cudaLogsDumpToFile(iterator, pathToFile, flags)
1179 return cudaLogsDumpToFile(iterator, pathToFile, flags)
1181cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1182 cdef bint usePTDS = cudaPythonInit()
1183 if usePTDS:
1184 return ptds._cudaLogsDumpToMemory(iterator, buffer, size, flags)
1185 return cudaLogsDumpToMemory(iterator, buffer, size, flags)
1187cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1188 cdef bint usePTDS = cudaPythonInit()
1189 if usePTDS:
1190 return ptds._cudaGraphCreate(pGraph, flags)
1191 return cudaGraphCreate(pGraph, flags)
1193cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1194 cdef bint usePTDS = cudaPythonInit()
1195 if usePTDS:
1196 return ptds._cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)
1197 return cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)
1199cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1200 cdef bint usePTDS = cudaPythonInit()
1201 if usePTDS:
1202 return ptds._cudaGraphKernelNodeGetParams(node, pNodeParams)
1203 return cudaGraphKernelNodeGetParams(node, pNodeParams)
1205cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1206 cdef bint usePTDS = cudaPythonInit()
1207 if usePTDS:
1208 return ptds._cudaGraphKernelNodeSetParams(node, pNodeParams)
1209 return cudaGraphKernelNodeSetParams(node, pNodeParams)
1211cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hDst, cudaGraphNode_t hSrc) except ?cudaErrorCallRequiresNewerDriver nogil:
1212 cdef bint usePTDS = cudaPythonInit()
1213 if usePTDS:
1214 return ptds._cudaGraphKernelNodeCopyAttributes(hDst, hSrc)
1215 return cudaGraphKernelNodeCopyAttributes(hDst, hSrc)
1217cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
1218 cdef bint usePTDS = cudaPythonInit()
1219 if usePTDS:
1220 return ptds._cudaGraphKernelNodeGetAttribute(hNode, attr, value_out)
1221 return cudaGraphKernelNodeGetAttribute(hNode, attr, value_out)
1223cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
1224 cdef bint usePTDS = cudaPythonInit()
1225 if usePTDS:
1226 return ptds._cudaGraphKernelNodeSetAttribute(hNode, attr, value)
1227 return cudaGraphKernelNodeSetAttribute(hNode, attr, value)
1229cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1230 cdef bint usePTDS = cudaPythonInit()
1231 if usePTDS:
1232 return ptds._cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams)
1233 return cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams)
1235cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
1236 cdef bint usePTDS = cudaPythonInit()
1237 if usePTDS:
1238 return ptds._cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind)
1239 return cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind)
1241cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1242 cdef bint usePTDS = cudaPythonInit()
1243 if usePTDS:
1244 return ptds._cudaGraphMemcpyNodeGetParams(node, pNodeParams)
1245 return cudaGraphMemcpyNodeGetParams(node, pNodeParams)
1247cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1248 cdef bint usePTDS = cudaPythonInit()
1249 if usePTDS:
1250 return ptds._cudaGraphMemcpyNodeSetParams(node, pNodeParams)
1251 return cudaGraphMemcpyNodeSetParams(node, pNodeParams)
1253cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
1254 cdef bint usePTDS = cudaPythonInit()
1255 if usePTDS:
1256 return ptds._cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind)
1257 return cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind)
1259cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1260 cdef bint usePTDS = cudaPythonInit()
1261 if usePTDS:
1262 return ptds._cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams)
1263 return cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams)
1265cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1266 cdef bint usePTDS = cudaPythonInit()
1267 if usePTDS:
1268 return ptds._cudaGraphMemsetNodeGetParams(node, pNodeParams)
1269 return cudaGraphMemsetNodeGetParams(node, pNodeParams)
1271cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1272 cdef bint usePTDS = cudaPythonInit()
1273 if usePTDS:
1274 return ptds._cudaGraphMemsetNodeSetParams(node, pNodeParams)
1275 return cudaGraphMemsetNodeSetParams(node, pNodeParams)
1277cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1278 cdef bint usePTDS = cudaPythonInit()
1279 if usePTDS:
1280 return ptds._cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)
1281 return cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)
1283cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1284 cdef bint usePTDS = cudaPythonInit()
1285 if usePTDS:
1286 return ptds._cudaGraphHostNodeGetParams(node, pNodeParams)
1287 return cudaGraphHostNodeGetParams(node, pNodeParams)
1289cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1290 cdef bint usePTDS = cudaPythonInit()
1291 if usePTDS:
1292 return ptds._cudaGraphHostNodeSetParams(node, pNodeParams)
1293 return cudaGraphHostNodeSetParams(node, pNodeParams)
1295cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
1296 cdef bint usePTDS = cudaPythonInit()
1297 if usePTDS:
1298 return ptds._cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph)
1299 return cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph)
1301cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
1302 cdef bint usePTDS = cudaPythonInit()
1303 if usePTDS:
1304 return ptds._cudaGraphChildGraphNodeGetGraph(node, pGraph)
1305 return cudaGraphChildGraphNodeGetGraph(node, pGraph)
1307cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
1308 cdef bint usePTDS = cudaPythonInit()
1309 if usePTDS:
1310 return ptds._cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies)
1311 return cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies)
1313cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
1314 cdef bint usePTDS = cudaPythonInit()
1315 if usePTDS:
1316 return ptds._cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event)
1317 return cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event)
1319cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
1320 cdef bint usePTDS = cudaPythonInit()
1321 if usePTDS:
1322 return ptds._cudaGraphEventRecordNodeGetEvent(node, event_out)
1323 return cudaGraphEventRecordNodeGetEvent(node, event_out)
1325cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
1326 cdef bint usePTDS = cudaPythonInit()
1327 if usePTDS:
1328 return ptds._cudaGraphEventRecordNodeSetEvent(node, event)
1329 return cudaGraphEventRecordNodeSetEvent(node, event)
1331cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
1332 cdef bint usePTDS = cudaPythonInit()
1333 if usePTDS:
1334 return ptds._cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event)
1335 return cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event)
1337cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
1338 cdef bint usePTDS = cudaPythonInit()
1339 if usePTDS:
1340 return ptds._cudaGraphEventWaitNodeGetEvent(node, event_out)
1341 return cudaGraphEventWaitNodeGetEvent(node, event_out)
1343cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
1344 cdef bint usePTDS = cudaPythonInit()
1345 if usePTDS:
1346 return ptds._cudaGraphEventWaitNodeSetEvent(node, event)
1347 return cudaGraphEventWaitNodeSetEvent(node, event)
1349cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1350 cdef bint usePTDS = cudaPythonInit()
1351 if usePTDS:
1352 return ptds._cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
1353 return cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
1355cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
1356 cdef bint usePTDS = cudaPythonInit()
1357 if usePTDS:
1358 return ptds._cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out)
1359 return cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out)
1361cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1362 cdef bint usePTDS = cudaPythonInit()
1363 if usePTDS:
1364 return ptds._cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams)
1365 return cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams)
1367cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1368 cdef bint usePTDS = cudaPythonInit()
1369 if usePTDS:
1370 return ptds._cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
1371 return cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
1373cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
1374 cdef bint usePTDS = cudaPythonInit()
1375 if usePTDS:
1376 return ptds._cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out)
1377 return cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out)
1379cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1380 cdef bint usePTDS = cudaPythonInit()
1381 if usePTDS:
1382 return ptds._cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams)
1383 return cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams)
1385cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1386 cdef bint usePTDS = cudaPythonInit()
1387 if usePTDS:
1388 return ptds._cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
1389 return cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
1391cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
1392 cdef bint usePTDS = cudaPythonInit()
1393 if usePTDS:
1394 return ptds._cudaGraphMemAllocNodeGetParams(node, params_out)
1395 return cudaGraphMemAllocNodeGetParams(node, params_out)
1397cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil:
1398 cdef bint usePTDS = cudaPythonInit()
1399 if usePTDS:
1400 return ptds._cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr)
1401 return cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr)
1403cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil:
1404 cdef bint usePTDS = cudaPythonInit()
1405 if usePTDS:
1406 return ptds._cudaGraphMemFreeNodeGetParams(node, dptr_out)
1407 return cudaGraphMemFreeNodeGetParams(node, dptr_out)
1409cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil:
1410 cdef bint usePTDS = cudaPythonInit()
1411 if usePTDS:
1412 return ptds._cudaDeviceGraphMemTrim(device)
1413 return cudaDeviceGraphMemTrim(device)
1415cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
1416 cdef bint usePTDS = cudaPythonInit()
1417 if usePTDS:
1418 return ptds._cudaDeviceGetGraphMemAttribute(device, attr, value)
1419 return cudaDeviceGetGraphMemAttribute(device, attr, value)
1421cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
1422 cdef bint usePTDS = cudaPythonInit()
1423 if usePTDS:
1424 return ptds._cudaDeviceSetGraphMemAttribute(device, attr, value)
1425 return cudaDeviceSetGraphMemAttribute(device, attr, value)
1427cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
1428 cdef bint usePTDS = cudaPythonInit()
1429 if usePTDS:
1430 return ptds._cudaGraphClone(pGraphClone, originalGraph)
1431 return cudaGraphClone(pGraphClone, originalGraph)
1433cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
1434 cdef bint usePTDS = cudaPythonInit()
1435 if usePTDS:
1436 return ptds._cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph)
1437 return cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph)
1439cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil:
1440 cdef bint usePTDS = cudaPythonInit()
1441 if usePTDS:
1442 return ptds._cudaGraphNodeGetType(node, pType)
1443 return cudaGraphNodeGetType(node, pType)
1445cdef cudaError_t _cudaGraphNodeGetContainingGraph(cudaGraphNode_t hNode, cudaGraph_t* phGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
1446 cdef bint usePTDS = cudaPythonInit()
1447 if usePTDS:
1448 return ptds._cudaGraphNodeGetContainingGraph(hNode, phGraph)
1449 return cudaGraphNodeGetContainingGraph(hNode, phGraph)
1451cdef cudaError_t _cudaGraphNodeGetLocalId(cudaGraphNode_t hNode, unsigned int* nodeId) except ?cudaErrorCallRequiresNewerDriver nogil:
1452 cdef bint usePTDS = cudaPythonInit()
1453 if usePTDS:
1454 return ptds._cudaGraphNodeGetLocalId(hNode, nodeId)
1455 return cudaGraphNodeGetLocalId(hNode, nodeId)
1457cdef cudaError_t _cudaGraphNodeGetToolsId(cudaGraphNode_t hNode, unsigned long long* toolsNodeId) except ?cudaErrorCallRequiresNewerDriver nogil:
1458 cdef bint usePTDS = cudaPythonInit()
1459 if usePTDS:
1460 return ptds._cudaGraphNodeGetToolsId(hNode, toolsNodeId)
1461 return cudaGraphNodeGetToolsId(hNode, toolsNodeId)
1463cdef cudaError_t _cudaGraphGetId(cudaGraph_t hGraph, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil:
1464 cdef bint usePTDS = cudaPythonInit()
1465 if usePTDS:
1466 return ptds._cudaGraphGetId(hGraph, graphID)
1467 return cudaGraphGetId(hGraph, graphID)
1469cdef cudaError_t _cudaGraphExecGetId(cudaGraphExec_t hGraphExec, unsigned int* graphID) except ?cudaErrorCallRequiresNewerDriver nogil:
1470 cdef bint usePTDS = cudaPythonInit()
1471 if usePTDS:
1472 return ptds._cudaGraphExecGetId(hGraphExec, graphID)
1473 return cudaGraphExecGetId(hGraphExec, graphID)
1475cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
1476 cdef bint usePTDS = cudaPythonInit()
1477 if usePTDS:
1478 return ptds._cudaGraphGetNodes(graph, nodes, numNodes)
1479 return cudaGraphGetNodes(graph, nodes, numNodes)
1481cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
1482 cdef bint usePTDS = cudaPythonInit()
1483 if usePTDS:
1484 return ptds._cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes)
1485 return cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes)
1487cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil:
1488 cdef bint usePTDS = cudaPythonInit()
1489 if usePTDS:
1490 return ptds._cudaGraphGetEdges(graph, from_, to, edgeData, numEdges)
1491 return cudaGraphGetEdges(graph, from_, to, edgeData, numEdges)
1493cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
1494 cdef bint usePTDS = cudaPythonInit()
1495 if usePTDS:
1496 return ptds._cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies)
1497 return cudaGraphNodeGetDependencies(node, pDependencies, edgeData, pNumDependencies)
1499cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
1500 cdef bint usePTDS = cudaPythonInit()
1501 if usePTDS:
1502 return ptds._cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes)
1503 return cudaGraphNodeGetDependentNodes(node, pDependentNodes, edgeData, pNumDependentNodes)
1505cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
1506 cdef bint usePTDS = cudaPythonInit()
1507 if usePTDS:
1508 return ptds._cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies)
1509 return cudaGraphAddDependencies(graph, from_, to, edgeData, numDependencies)
1511cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
1512 cdef bint usePTDS = cudaPythonInit()
1513 if usePTDS:
1514 return ptds._cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies)
1515 return cudaGraphRemoveDependencies(graph, from_, to, edgeData, numDependencies)
1517cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil:
1518 cdef bint usePTDS = cudaPythonInit()
1519 if usePTDS:
1520 return ptds._cudaGraphDestroyNode(node)
1521 return cudaGraphDestroyNode(node)
1523cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1524 cdef bint usePTDS = cudaPythonInit()
1525 if usePTDS:
1526 return ptds._cudaGraphInstantiate(pGraphExec, graph, flags)
1527 return cudaGraphInstantiate(pGraphExec, graph, flags)
1529cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1530 cdef bint usePTDS = cudaPythonInit()
1531 if usePTDS:
1532 return ptds._cudaGraphInstantiateWithFlags(pGraphExec, graph, flags)
1533 return cudaGraphInstantiateWithFlags(pGraphExec, graph, flags)
1535cdef cudaError_t _cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1536 cdef bint usePTDS = cudaPythonInit()
1537 if usePTDS:
1538 return ptds._cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams)
1539 return cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams)
1541cdef cudaError_t _cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1542 cdef bint usePTDS = cudaPythonInit()
1543 if usePTDS:
1544 return ptds._cudaGraphExecGetFlags(graphExec, flags)
1545 return cudaGraphExecGetFlags(graphExec, flags)
1547cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1548 cdef bint usePTDS = cudaPythonInit()
1549 if usePTDS:
1550 return ptds._cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams)
1551 return cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams)
1553cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1554 cdef bint usePTDS = cudaPythonInit()
1555 if usePTDS:
1556 return ptds._cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams)
1557 return cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams)
1559cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
1560 cdef bint usePTDS = cudaPythonInit()
1561 if usePTDS:
1562 return ptds._cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind)
1563 return cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind)
1565cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1566 cdef bint usePTDS = cudaPythonInit()
1567 if usePTDS:
1568 return ptds._cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams)
1569 return cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams)
1571cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1572 cdef bint usePTDS = cudaPythonInit()
1573 if usePTDS:
1574 return ptds._cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams)
1575 return cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams)
1577cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
1578 cdef bint usePTDS = cudaPythonInit()
1579 if usePTDS:
1580 return ptds._cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph)
1581 return cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph)
1583cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
1584 cdef bint usePTDS = cudaPythonInit()
1585 if usePTDS:
1586 return ptds._cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event)
1587 return cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event)
1589cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
1590 cdef bint usePTDS = cudaPythonInit()
1591 if usePTDS:
1592 return ptds._cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event)
1593 return cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event)
1595cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1596 cdef bint usePTDS = cudaPythonInit()
1597 if usePTDS:
1598 return ptds._cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams)
1599 return cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams)
1601cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1602 cdef bint usePTDS = cudaPythonInit()
1603 if usePTDS:
1604 return ptds._cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams)
1605 return cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams)
1607cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
1608 cdef bint usePTDS = cudaPythonInit()
1609 if usePTDS:
1610 return ptds._cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled)
1611 return cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled)
1613cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
1614 cdef bint usePTDS = cudaPythonInit()
1615 if usePTDS:
1616 return ptds._cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled)
1617 return cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled)
1619cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil:
1620 cdef bint usePTDS = cudaPythonInit()
1621 if usePTDS:
1622 return ptds._cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo)
1623 return cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo)
1625cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
1626 cdef bint usePTDS = cudaPythonInit()
1627 if usePTDS:
1628 return ptds._cudaGraphUpload(graphExec, stream)
1629 return cudaGraphUpload(graphExec, stream)
1631cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
1632 cdef bint usePTDS = cudaPythonInit()
1633 if usePTDS:
1634 return ptds._cudaGraphLaunch(graphExec, stream)
1635 return cudaGraphLaunch(graphExec, stream)
1637cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil:
1638 cdef bint usePTDS = cudaPythonInit()
1639 if usePTDS:
1640 return ptds._cudaGraphExecDestroy(graphExec)
1641 return cudaGraphExecDestroy(graphExec)
1643cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil:
1644 cdef bint usePTDS = cudaPythonInit()
1645 if usePTDS:
1646 return ptds._cudaGraphDestroy(graph)
1647 return cudaGraphDestroy(graph)
1649cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1650 cdef bint usePTDS = cudaPythonInit()
1651 if usePTDS:
1652 return ptds._cudaGraphDebugDotPrint(graph, path, flags)
1653 return cudaGraphDebugDotPrint(graph, path, flags)
1655cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1656 cdef bint usePTDS = cudaPythonInit()
1657 if usePTDS:
1658 return ptds._cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags)
1659 return cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags)
1661cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
1662 cdef bint usePTDS = cudaPythonInit()
1663 if usePTDS:
1664 return ptds._cudaUserObjectRetain(object, count)
1665 return cudaUserObjectRetain(object, count)
1667cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
1668 cdef bint usePTDS = cudaPythonInit()
1669 if usePTDS:
1670 return ptds._cudaUserObjectRelease(object, count)
1671 return cudaUserObjectRelease(object, count)
1673cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1674 cdef bint usePTDS = cudaPythonInit()
1675 if usePTDS:
1676 return ptds._cudaGraphRetainUserObject(graph, object, count, flags)
1677 return cudaGraphRetainUserObject(graph, object, count, flags)
1679cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
1680 cdef bint usePTDS = cudaPythonInit()
1681 if usePTDS:
1682 return ptds._cudaGraphReleaseUserObject(graph, object, count)
1683 return cudaGraphReleaseUserObject(graph, object, count)
1685cdef cudaError_t _cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1686 cdef bint usePTDS = cudaPythonInit()
1687 if usePTDS:
1688 return ptds._cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams)
1689 return cudaGraphAddNode(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams)
1691cdef cudaError_t _cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1692 cdef bint usePTDS = cudaPythonInit()
1693 if usePTDS:
1694 return ptds._cudaGraphNodeSetParams(node, nodeParams)
1695 return cudaGraphNodeSetParams(node, nodeParams)
1697cdef cudaError_t _cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1698 cdef bint usePTDS = cudaPythonInit()
1699 if usePTDS:
1700 return ptds._cudaGraphExecNodeSetParams(graphExec, node, nodeParams)
1701 return cudaGraphExecNodeSetParams(graphExec, node, nodeParams)
1703cdef cudaError_t _cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1704 cdef bint usePTDS = cudaPythonInit()
1705 if usePTDS:
1706 return ptds._cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags)
1707 return cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags)
1709cdef cudaError_t _cudaGraphConditionalHandleCreate_v2(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, cudaExecutionContext_t ctx, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1710 cdef bint usePTDS = cudaPythonInit()
1711 if usePTDS:
1712 return ptds._cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags)
1713 return cudaGraphConditionalHandleCreate_v2(pHandle_out, graph, ctx, defaultLaunchValue, flags)
1715cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
1716 cdef bint usePTDS = cudaPythonInit()
1717 if usePTDS:
1718 return ptds._cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus)
1719 return cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus)
1721cdef cudaError_t _cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
1722 cdef bint usePTDS = cudaPythonInit()
1723 if usePTDS:
1724 return ptds._cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus)
1725 return cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus)
1727cdef cudaError_t _cudaLibraryLoadData(cudaLibrary_t* library, const void* code, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil:
1728 cdef bint usePTDS = cudaPythonInit()
1729 if usePTDS:
1730 return ptds._cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions)
1731 return cudaLibraryLoadData(library, code, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions)
1733cdef cudaError_t _cudaLibraryLoadFromFile(cudaLibrary_t* library, const char* fileName, cudaJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, cudaLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) except ?cudaErrorCallRequiresNewerDriver nogil:
1734 cdef bint usePTDS = cudaPythonInit()
1735 if usePTDS:
1736 return ptds._cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions)
1737 return cudaLibraryLoadFromFile(library, fileName, jitOptions, jitOptionsValues, numJitOptions, libraryOptions, libraryOptionValues, numLibraryOptions)
1739cdef cudaError_t _cudaLibraryUnload(cudaLibrary_t library) except ?cudaErrorCallRequiresNewerDriver nogil:
1740 cdef bint usePTDS = cudaPythonInit()
1741 if usePTDS:
1742 return ptds._cudaLibraryUnload(library)
1743 return cudaLibraryUnload(library)
1745cdef cudaError_t _cudaLibraryGetKernel(cudaKernel_t* pKernel, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil:
1746 cdef bint usePTDS = cudaPythonInit()
1747 if usePTDS:
1748 return ptds._cudaLibraryGetKernel(pKernel, library, name)
1749 return cudaLibraryGetKernel(pKernel, library, name)
1751cdef cudaError_t _cudaLibraryGetGlobal(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil:
1752 cdef bint usePTDS = cudaPythonInit()
1753 if usePTDS:
1754 return ptds._cudaLibraryGetGlobal(dptr, numbytes, library, name)
1755 return cudaLibraryGetGlobal(dptr, numbytes, library, name)
1757cdef cudaError_t _cudaLibraryGetManaged(void** dptr, size_t* numbytes, cudaLibrary_t library, const char* name) except ?cudaErrorCallRequiresNewerDriver nogil:
1758 cdef bint usePTDS = cudaPythonInit()
1759 if usePTDS:
1760 return ptds._cudaLibraryGetManaged(dptr, numbytes, library, name)
1761 return cudaLibraryGetManaged(dptr, numbytes, library, name)
1763cdef cudaError_t _cudaLibraryGetUnifiedFunction(void** fptr, cudaLibrary_t library, const char* symbol) except ?cudaErrorCallRequiresNewerDriver nogil:
1764 cdef bint usePTDS = cudaPythonInit()
1765 if usePTDS:
1766 return ptds._cudaLibraryGetUnifiedFunction(fptr, library, symbol)
1767 return cudaLibraryGetUnifiedFunction(fptr, library, symbol)
1769cdef cudaError_t _cudaLibraryGetKernelCount(unsigned int* count, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil:
1770 cdef bint usePTDS = cudaPythonInit()
1771 if usePTDS:
1772 return ptds._cudaLibraryGetKernelCount(count, lib)
1773 return cudaLibraryGetKernelCount(count, lib)
1775cdef cudaError_t _cudaLibraryEnumerateKernels(cudaKernel_t* kernels, unsigned int numKernels, cudaLibrary_t lib) except ?cudaErrorCallRequiresNewerDriver nogil:
1776 cdef bint usePTDS = cudaPythonInit()
1777 if usePTDS:
1778 return ptds._cudaLibraryEnumerateKernels(kernels, numKernels, lib)
1779 return cudaLibraryEnumerateKernels(kernels, numKernels, lib)
1781cdef cudaError_t _cudaKernelSetAttributeForDevice(cudaKernel_t kernel, cudaFuncAttribute attr, int value, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
1782 cdef bint usePTDS = cudaPythonInit()
1783 if usePTDS:
1784 return ptds._cudaKernelSetAttributeForDevice(kernel, attr, value, device)
1785 return cudaKernelSetAttributeForDevice(kernel, attr, value, device)
1787cdef cudaError_t _cudaDeviceGetDevResource(int device, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil:
1788 cdef bint usePTDS = cudaPythonInit()
1789 if usePTDS:
1790 return ptds._cudaDeviceGetDevResource(device, resource, typename)
1791 return cudaDeviceGetDevResource(device, resource, typename)
1793cdef cudaError_t _cudaDevSmResourceSplitByCount(cudaDevResource* result, unsigned int* nbGroups, const cudaDevResource* input, cudaDevResource* remaining, unsigned int flags, unsigned int minCount) except ?cudaErrorCallRequiresNewerDriver nogil:
1794 cdef bint usePTDS = cudaPythonInit()
1795 if usePTDS:
1796 return ptds._cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount)
1797 return cudaDevSmResourceSplitByCount(result, nbGroups, input, remaining, flags, minCount)
1799cdef cudaError_t _cudaDevSmResourceSplit(cudaDevResource* result, unsigned int nbGroups, const cudaDevResource* input, cudaDevResource* remainder, unsigned int flags, cudaDevSmResourceGroupParams* groupParams) except ?cudaErrorCallRequiresNewerDriver nogil:
1800 cdef bint usePTDS = cudaPythonInit()
1801 if usePTDS:
1802 return ptds._cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams)
1803 return cudaDevSmResourceSplit(result, nbGroups, input, remainder, flags, groupParams)
1805cdef cudaError_t _cudaDevResourceGenerateDesc(cudaDevResourceDesc_t* phDesc, cudaDevResource* resources, unsigned int nbResources) except ?cudaErrorCallRequiresNewerDriver nogil:
1806 cdef bint usePTDS = cudaPythonInit()
1807 if usePTDS:
1808 return ptds._cudaDevResourceGenerateDesc(phDesc, resources, nbResources)
1809 return cudaDevResourceGenerateDesc(phDesc, resources, nbResources)
1811cdef cudaError_t _cudaGreenCtxCreate(cudaExecutionContext_t* phCtx, cudaDevResourceDesc_t desc, int device, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
1812 cdef bint usePTDS = cudaPythonInit()
1813 if usePTDS:
1814 return ptds._cudaGreenCtxCreate(phCtx, desc, device, flags)
1815 return cudaGreenCtxCreate(phCtx, desc, device, flags)
1817cdef cudaError_t _cudaExecutionCtxDestroy(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil:
1818 cdef bint usePTDS = cudaPythonInit()
1819 if usePTDS:
1820 return ptds._cudaExecutionCtxDestroy(ctx)
1821 return cudaExecutionCtxDestroy(ctx)
1823cdef cudaError_t _cudaExecutionCtxGetDevResource(cudaExecutionContext_t ctx, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil:
1824 cdef bint usePTDS = cudaPythonInit()
1825 if usePTDS:
1826 return ptds._cudaExecutionCtxGetDevResource(ctx, resource, typename)
1827 return cudaExecutionCtxGetDevResource(ctx, resource, typename)
1829cdef cudaError_t _cudaExecutionCtxGetDevice(int* device, cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil:
1830 cdef bint usePTDS = cudaPythonInit()
1831 if usePTDS:
1832 return ptds._cudaExecutionCtxGetDevice(device, ctx)
1833 return cudaExecutionCtxGetDevice(device, ctx)
1835cdef cudaError_t _cudaExecutionCtxGetId(cudaExecutionContext_t ctx, unsigned long long* ctxId) except ?cudaErrorCallRequiresNewerDriver nogil:
1836 cdef bint usePTDS = cudaPythonInit()
1837 if usePTDS:
1838 return ptds._cudaExecutionCtxGetId(ctx, ctxId)
1839 return cudaExecutionCtxGetId(ctx, ctxId)
1841cdef cudaError_t _cudaExecutionCtxStreamCreate(cudaStream_t* phStream, cudaExecutionContext_t ctx, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil:
1842 cdef bint usePTDS = cudaPythonInit()
1843 if usePTDS:
1844 return ptds._cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority)
1845 return cudaExecutionCtxStreamCreate(phStream, ctx, flags, priority)
1847cdef cudaError_t _cudaExecutionCtxSynchronize(cudaExecutionContext_t ctx) except ?cudaErrorCallRequiresNewerDriver nogil:
1848 cdef bint usePTDS = cudaPythonInit()
1849 if usePTDS:
1850 return ptds._cudaExecutionCtxSynchronize(ctx)
1851 return cudaExecutionCtxSynchronize(ctx)
1853cdef cudaError_t _cudaStreamGetDevResource(cudaStream_t hStream, cudaDevResource* resource, cudaDevResourceType typename) except ?cudaErrorCallRequiresNewerDriver nogil:
1854 cdef bint usePTDS = cudaPythonInit()
1855 if usePTDS:
1856 return ptds._cudaStreamGetDevResource(hStream, resource, typename)
1857 return cudaStreamGetDevResource(hStream, resource, typename)
1859cdef cudaError_t _cudaExecutionCtxRecordEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
1860 cdef bint usePTDS = cudaPythonInit()
1861 if usePTDS:
1862 return ptds._cudaExecutionCtxRecordEvent(ctx, event)
1863 return cudaExecutionCtxRecordEvent(ctx, event)
1865cdef cudaError_t _cudaExecutionCtxWaitEvent(cudaExecutionContext_t ctx, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
1866 cdef bint usePTDS = cudaPythonInit()
1867 if usePTDS:
1868 return ptds._cudaExecutionCtxWaitEvent(ctx, event)
1869 return cudaExecutionCtxWaitEvent(ctx, event)
1871cdef cudaError_t _cudaDeviceGetExecutionCtx(cudaExecutionContext_t* ctx, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
1872 cdef bint usePTDS = cudaPythonInit()
1873 if usePTDS:
1874 return ptds._cudaDeviceGetExecutionCtx(ctx, device)
1875 return cudaDeviceGetExecutionCtx(ctx, device)
1877cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil:
1878 cdef bint usePTDS = cudaPythonInit()
1879 if usePTDS:
1880 return ptds._cudaGetExportTable(ppExportTable, pExportTableId)
1881 return cudaGetExportTable(ppExportTable, pExportTableId)
1883cdef cudaError_t _cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil:
1884 cdef bint usePTDS = cudaPythonInit()
1885 if usePTDS:
1886 return ptds._cudaGetKernel(kernelPtr, entryFuncAddr)
1887 return cudaGetKernel(kernelPtr, entryFuncAddr)
1888@cython.show_performance_hints(False)
1889cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) except* nogil:
1890 cdef bint usePTDS = cudaPythonInit()
1891 if usePTDS:
1892 return ptds._make_cudaPitchedPtr(d, p, xsz, ysz)
1893 return make_cudaPitchedPtr(d, p, xsz, ysz)
1894@cython.show_performance_hints(False)
1895cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) except* nogil:
1896 cdef bint usePTDS = cudaPythonInit()
1897 if usePTDS:
1898 return ptds._make_cudaPos(x, y, z)
1899 return make_cudaPos(x, y, z)
1900@cython.show_performance_hints(False)
1901cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) except* nogil:
1902 cdef bint usePTDS = cudaPythonInit()
1903 if usePTDS:
1904 return ptds._make_cudaExtent(w, h, d)
1905 return make_cudaExtent(w, h, d)
1907cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil:
1908 cdef bint usePTDS = cudaPythonInit()
1909 if usePTDS:
1910 return ptds._cudaProfilerStart()
1911 return cudaProfilerStart()
1913cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil:
1914 cdef bint usePTDS = cudaPythonInit()
1915 if usePTDS:
1916 return ptds._cudaProfilerStop()
1917 return cudaProfilerStop()
1920include "../_lib/cyruntime/cyruntime.pxi"