Coverage for cuda / bindings / _bindings / cyruntime.pyx: 35.40%

1# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. (empty)

2# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE 

3  

4# This code was automatically generated with version 13.2.0, generator version 8797618. Do not modify it directly. 

5include "../cyruntime_functions.pxi" 

6  

7import os (empty)

8cimport cuda.bindings._bindings.cyruntime_ptds as ptds 

9cimport cython 

10  

11cdef bint __cudaPythonInit = False (empty)

12cdef bint __usePTDS = False (empty)

13cdef int _cudaPythonInit() except -1 nogil: (empty)

14 global __cudaPythonInit 

15 global __usePTDS 

16  

17 with gil: 2 ctx1aC

18 __usePTDS = os.getenv('CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM', default=False) 2 ctx1aC

19 __cudaPythonInit = True 2 ctx1aC

20 return __usePTDS 2 ctx1aC

21  

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: (empty)

25 if __cudaPythonInit: 131 ctx2a R S T U V W C X Y Z q 0 x y r s 1 k f d i g l e b c j h m n o t u v D 2 w z E 3 4 5 6 7 8 F G H 9 ! I J A B K L M N O P Q p # $ % ' ( ) * + , - . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPb

26 return __usePTDS 130 ctx2a R S T U V W X Y Z q 0 x y r s 1 k f d i g l e b c j h m n o t u v D 2 w z E 3 4 5 6 7 8 F G H 9 ! I J A B K L M N O P Q p # $ % ' ( ) * + , - . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPb

27 return _cudaPythonInit() 2 ctx1aC

28  

29cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

30 cdef bint usePTDS = cudaPythonInit() 

31 if usePTDS: (empty)

32 return ptds._cudaDeviceReset() 

33 return cudaDeviceReset() 

34  

35cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

36 cdef bint usePTDS = cudaPythonInit() 79 ctx2R S T U V W u 4 5 9 ! # $ % ' ( ) * + , - . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPb

37 if usePTDS: 79 ctx2R S T U V W u 4 5 9 ! # $ % ' ( ) * + , - . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPb

38 return ptds._cudaDeviceSynchronize() 

39 return cudaDeviceSynchronize() 79 ctx2R S T U V W u 4 5 9 ! # $ % ' ( ) * + , - . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPb

40  

41cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

42 cdef bint usePTDS = cudaPythonInit() 

43 if usePTDS: 

44 return ptds._cudaDeviceSetLimit(limit, value) 

45 return cudaDeviceSetLimit(limit, value) 

46  

47cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

48 cdef bint usePTDS = cudaPythonInit() 

49 if usePTDS: 

50 return ptds._cudaDeviceGetLimit(pValue, limit) 

51 return cudaDeviceGetLimit(pValue, limit) 

52  

53cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

54 cdef bint usePTDS = cudaPythonInit() 

55 if usePTDS: 

56 return ptds._cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) 

57 return cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device) 

58  

59cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

60 cdef bint usePTDS = cudaPythonInit() 

61 if usePTDS: (empty)

62 return ptds._cudaDeviceGetCacheConfig(pCacheConfig) 

63 return cudaDeviceGetCacheConfig(pCacheConfig) 

64  

65cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

66 cdef bint usePTDS = cudaPythonInit() 

67 if usePTDS: 

68 return ptds._cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) 

69 return cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority) 

70  

71cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

72 cdef bint usePTDS = cudaPythonInit() 

73 if usePTDS: (empty)

74 return ptds._cudaDeviceSetCacheConfig(cacheConfig) 

75 return cudaDeviceSetCacheConfig(cacheConfig) 

76  

77cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

78 cdef bint usePTDS = cudaPythonInit() 

79 if usePTDS: 

80 return ptds._cudaDeviceGetByPCIBusId(device, pciBusId) 

81 return cudaDeviceGetByPCIBusId(device, pciBusId) 

82  

83cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

84 cdef bint usePTDS = cudaPythonInit() 3 ctx1C78

85 if usePTDS: 3 ctx1C78

86 return ptds._cudaDeviceGetPCIBusId(pciBusId, length, device) 

87 return cudaDeviceGetPCIBusId(pciBusId, length, device) 3 ctx1C78

88  

89cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

90 cdef bint usePTDS = cudaPythonInit() 

91 if usePTDS: (empty)

92 return ptds._cudaIpcGetEventHandle(handle, event) 

93 return cudaIpcGetEventHandle(handle, event) 

94  

95cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

96 cdef bint usePTDS = cudaPythonInit() 

97 if usePTDS: 

98 return ptds._cudaIpcOpenEventHandle(event, handle) 

99 return cudaIpcOpenEventHandle(event, handle) 

100  

101cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

102 cdef bint usePTDS = cudaPythonInit() 

103 if usePTDS: 

104 return ptds._cudaIpcGetMemHandle(handle, devPtr) 

105 return cudaIpcGetMemHandle(handle, devPtr) 

106  

107cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

108 cdef bint usePTDS = cudaPythonInit() 

109 if usePTDS: (empty)

110 return ptds._cudaIpcOpenMemHandle(devPtr, handle, flags) 

111 return cudaIpcOpenMemHandle(devPtr, handle, flags) 

112  

113cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

114 cdef bint usePTDS = cudaPythonInit() 

115 if usePTDS: 

116 return ptds._cudaIpcCloseMemHandle(devPtr) 

117 return cudaIpcCloseMemHandle(devPtr) 

118  

119cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

120 cdef bint usePTDS = cudaPythonInit() 

121 if usePTDS: 

122 return ptds._cudaDeviceFlushGPUDirectRDMAWrites(target, scope) 

123 return cudaDeviceFlushGPUDirectRDMAWrites(target, scope) 

124  

125cdef cudaError_t _cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

126 cdef bint usePTDS = cudaPythonInit() 

127 if usePTDS: (empty)

128 return ptds._cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) 

129 return cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback) 

130  

131cdef cudaError_t _cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

132 cdef bint usePTDS = cudaPythonInit() 

133 if usePTDS: 

134 return ptds._cudaDeviceUnregisterAsyncNotification(device, callback) 

135 return cudaDeviceUnregisterAsyncNotification(device, callback) 

136  

137cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

138 cdef bint usePTDS = cudaPythonInit() 

139 if usePTDS: 

140 return ptds._cudaDeviceGetSharedMemConfig(pConfig) 

141 return cudaDeviceGetSharedMemConfig(pConfig) 

142  

143cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

144 cdef bint usePTDS = cudaPythonInit() 

145 if usePTDS: (empty)

146 return ptds._cudaDeviceSetSharedMemConfig(config) 

147 return cudaDeviceSetSharedMemConfig(config) 

148  

149cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

150 cdef bint usePTDS = cudaPythonInit() 

151 if usePTDS: 

152 return ptds._cudaGetLastError() 

153 return cudaGetLastError() 

154  

155cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

156 cdef bint usePTDS = cudaPythonInit() 

157 if usePTDS: 

158 return ptds._cudaPeekAtLastError() 

159 return cudaPeekAtLastError() 

160  

161cdef const char* _cudaGetErrorName(cudaError_t error) except ?NULL nogil: (empty)

162 cdef bint usePTDS = cudaPythonInit() 4 ctx1ZFGH

163 if usePTDS: 5 ctx1aZFGH

164 return ptds._cudaGetErrorName(error) 

165 return cudaGetErrorName(error) 4 ctx1ZFGH

166  

167cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil: (empty)

168 cdef bint usePTDS = cudaPythonInit() 1 ctx1H

169 if usePTDS: 1 ctx1H

170 return ptds._cudaGetErrorString(error) 

171 return cudaGetErrorString(error) 1 ctx1H

172  

173cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

174 cdef bint usePTDS = cudaPythonInit() 2 ctx1XY

175 if usePTDS: 2 ctx1XY

176 return ptds._cudaGetDeviceCount(count) 

177 return cudaGetDeviceCount(count) 2 ctx1XY

178  

179cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

180 cdef bint usePTDS = cudaPythonInit() 2 ctx112

181 if usePTDS: 3 ctx1a12

182 return ptds._cudaGetDeviceProperties(prop, device) 

183 return cudaGetDeviceProperties(prop, device) 2 ctx112

184  

185cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

186 cdef bint usePTDS = cudaPythonInit() 2 ctx1a3

187 if usePTDS: 2 ctx1a3

188 return ptds._cudaDeviceGetAttribute(value, attr, device) 

189 return cudaDeviceGetAttribute(value, attr, device) 2 ctx1a3

190  

191cdef cudaError_t _cudaDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

192 cdef bint usePTDS = cudaPythonInit() 

193 if usePTDS: 

194 return ptds._cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) 

195 return cudaDeviceGetHostAtomicCapabilities(capabilities, operations, count, device) 

196  

197cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

198 cdef bint usePTDS = cudaPythonInit() 1 ctx1L

199 if usePTDS: 1 ctx1L

200 return ptds._cudaDeviceGetDefaultMemPool(memPool, device) 

201 return cudaDeviceGetDefaultMemPool(memPool, device) 2 ctx1aL

202  

203cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

204 cdef bint usePTDS = cudaPythonInit() 1 ctx1L

205 if usePTDS: 2 ctx1aL

206 return ptds._cudaDeviceSetMemPool(device, memPool) 

207 return cudaDeviceSetMemPool(device, memPool) 1 ctx1L

208  

209cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

210 cdef bint usePTDS = cudaPythonInit() 

211 if usePTDS: 

212 return ptds._cudaDeviceGetMemPool(memPool, device) 

213 return cudaDeviceGetMemPool(memPool, device) 

214  

215cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

216 cdef bint usePTDS = cudaPythonInit() 

217 if usePTDS: 

218 return ptds._cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) 

219 return cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags) 

220  

221cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

222 cdef bint usePTDS = cudaPythonInit() 

223 if usePTDS: 

224 return ptds._cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) 

225 return cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice) 

226  

227cdef cudaError_t _cudaDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const cudaAtomicOperation* operations, unsigned int count, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

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) 

232  

233cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

234 cdef bint usePTDS = cudaPythonInit() 

235 if usePTDS: 

236 return ptds._cudaChooseDevice(device, prop) 

237 return cudaChooseDevice(device, prop) 

238  

239cdef cudaError_t _cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

240 cdef bint usePTDS = cudaPythonInit() 

241 if usePTDS: 

242 return ptds._cudaInitDevice(device, deviceFlags, flags) 

243 return cudaInitDevice(device, deviceFlags, flags) 

244  

245cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

246 cdef bint usePTDS = cudaPythonInit() 

247 if usePTDS: 

248 return ptds._cudaSetDevice(device) 

249 return cudaSetDevice(device) 

250  

251cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

252 cdef bint usePTDS = cudaPythonInit() 1 ctx16

253 if usePTDS: 1 ctx16

254 return ptds._cudaGetDevice(device) 

255 return cudaGetDevice(device) 1 ctx16

256  

257cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

258 cdef bint usePTDS = cudaPythonInit() 

259 if usePTDS: 

260 return ptds._cudaSetDeviceFlags(flags) 

261 return cudaSetDeviceFlags(flags) 

262  

263cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

264 cdef bint usePTDS = cudaPythonInit() 

265 if usePTDS: 

266 return ptds._cudaGetDeviceFlags(flags) 

267 return cudaGetDeviceFlags(flags) 

268  

269cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

270 cdef bint usePTDS = cudaPythonInit() 7 ctx1fdebtuM

271 if usePTDS: 7 ctx1fdebtuM

272 return ptds._cudaStreamCreate(pStream) 

273 return cudaStreamCreate(pStream) 7 ctx1fdebtuM

274  

275cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

276 cdef bint usePTDS = cudaPythonInit() 1 ctx1v

277 if usePTDS: 1 ctx1v

278 return ptds._cudaStreamCreateWithFlags(pStream, flags) 

279 return cudaStreamCreateWithFlags(pStream, flags) 1 ctx1v

280  

281cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

282 cdef bint usePTDS = cudaPythonInit() 

283 if usePTDS: 

284 return ptds._cudaStreamCreateWithPriority(pStream, flags, priority) 

285 return cudaStreamCreateWithPriority(pStream, flags, priority) 

286  

287cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

288 cdef bint usePTDS = cudaPythonInit() 

289 if usePTDS: 

290 return ptds._cudaStreamGetPriority(hStream, priority) 

291 return cudaStreamGetPriority(hStream, priority) 

292  

293cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

294 cdef bint usePTDS = cudaPythonInit() 

295 if usePTDS: 

296 return ptds._cudaStreamGetFlags(hStream, flags) 

297 return cudaStreamGetFlags(hStream, flags) 

298  

299cdef cudaError_t _cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

300 cdef bint usePTDS = cudaPythonInit() 

301 if usePTDS: 

302 return ptds._cudaStreamGetId(hStream, streamId) 

303 return cudaStreamGetId(hStream, streamId) 

304  

305cdef cudaError_t _cudaStreamGetDevice(cudaStream_t hStream, int* device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

306 cdef bint usePTDS = cudaPythonInit() 

307 if usePTDS: 

308 return ptds._cudaStreamGetDevice(hStream, device) 

309 return cudaStreamGetDevice(hStream, device) 

310  

311cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

312 cdef bint usePTDS = cudaPythonInit() 

313 if usePTDS: 

314 return ptds._cudaCtxResetPersistingL2Cache() 

315 return cudaCtxResetPersistingL2Cache() 

316  

317cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

318 cdef bint usePTDS = cudaPythonInit() 

319 if usePTDS: 

320 return ptds._cudaStreamCopyAttributes(dst, src) 

321 return cudaStreamCopyAttributes(dst, src) 

322  

323cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

324 cdef bint usePTDS = cudaPythonInit() 

325 if usePTDS: 

326 return ptds._cudaStreamGetAttribute(hStream, attr, value_out) 

327 return cudaStreamGetAttribute(hStream, attr, value_out) 

328  

329cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

330 cdef bint usePTDS = cudaPythonInit() 

331 if usePTDS: 

332 return ptds._cudaStreamSetAttribute(hStream, attr, value) 

333 return cudaStreamSetAttribute(hStream, attr, value) 

334  

335cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

336 cdef bint usePTDS = cudaPythonInit() 1 ctx1M

337 if usePTDS: 1 ctx1M

338 return ptds._cudaStreamDestroy(stream) 

339 return cudaStreamDestroy(stream) 1 ctx1M

340  

341cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

342 cdef bint usePTDS = cudaPythonInit() 

343 if usePTDS: 

344 return ptds._cudaStreamWaitEvent(stream, event, flags) 

345 return cudaStreamWaitEvent(stream, event, flags) 

346  

347cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

348 cdef bint usePTDS = cudaPythonInit() 1 ctx1u

349 if usePTDS: 1 ctx1u

350 return ptds._cudaStreamAddCallback(stream, callback, userData, flags) 

351 return cudaStreamAddCallback(stream, callback, userData, flags) 1 ctx1u

352  

353cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

354 cdef bint usePTDS = cudaPythonInit() 4 ctx1fdeb

355 if usePTDS: 4 ctx1fdeb

356 return ptds._cudaStreamSynchronize(stream) 

357 return cudaStreamSynchronize(stream) 4 ctx1fdeb

358  

359cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

360 cdef bint usePTDS = cudaPythonInit() 

361 if usePTDS: 

362 return ptds._cudaStreamQuery(stream) 

363 return cudaStreamQuery(stream) 

364  

365cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

366 cdef bint usePTDS = cudaPythonInit() 

367 if usePTDS: 

368 return ptds._cudaStreamAttachMemAsync(stream, devPtr, length, flags) 

369 return cudaStreamAttachMemAsync(stream, devPtr, length, flags) 

370  

371cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

372 cdef bint usePTDS = cudaPythonInit() 1 ctx1t

373 if usePTDS: 1 ctx1t

374 return ptds._cudaStreamBeginCapture(stream, mode) 

375 return cudaStreamBeginCapture(stream, mode) 1 ctx1t

376  

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: (empty)

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) 

382  

383cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

384 cdef bint usePTDS = cudaPythonInit() 1 ctx10

385 if usePTDS: 1 ctx10

386 return ptds._cudaThreadExchangeStreamCaptureMode(mode) 

387 return cudaThreadExchangeStreamCaptureMode(mode) 1 ctx10

388  

389cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

390 cdef bint usePTDS = cudaPythonInit() 1 ctx1t

391 if usePTDS: 1 ctx1t

392 return ptds._cudaStreamEndCapture(stream, pGraph) 

393 return cudaStreamEndCapture(stream, pGraph) 1 ctx1t

394  

395cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

396 cdef bint usePTDS = cudaPythonInit() 

397 if usePTDS: 

398 return ptds._cudaStreamIsCapturing(stream, pCaptureStatus) 

399 return cudaStreamIsCapturing(stream, pCaptureStatus) 

400  

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: (empty)

402 cdef bint usePTDS = cudaPythonInit() 1 ctx1t

403 if usePTDS: 1 ctx1t

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) 1 ctx1t

406  

407cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

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) 

412  

413cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

414 cdef bint usePTDS = cudaPythonInit() 1 ctx1J

415 if usePTDS: 1 ctx1J

416 return ptds._cudaEventCreate(event) 

417 return cudaEventCreate(event) 1 ctx1J

418  

419cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

420 cdef bint usePTDS = cudaPythonInit() 

421 if usePTDS: 

422 return ptds._cudaEventCreateWithFlags(event, flags) (empty)

423 return cudaEventCreateWithFlags(event, flags) 

424  

425cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

426 cdef bint usePTDS = cudaPythonInit() 

427 if usePTDS: 

428 return ptds._cudaEventRecord(event, stream) 

429 return cudaEventRecord(event, stream) 

430  

431cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

432 cdef bint usePTDS = cudaPythonInit() 

433 if usePTDS: 

434 return ptds._cudaEventRecordWithFlags(event, stream, flags) 

435 return cudaEventRecordWithFlags(event, stream, flags) 

436  

437cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

438 cdef bint usePTDS = cudaPythonInit() 

439 if usePTDS: 

440 return ptds._cudaEventQuery(event) 

441 return cudaEventQuery(event) 

442  

443cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

444 cdef bint usePTDS = cudaPythonInit() 

445 if usePTDS: 

446 return ptds._cudaEventSynchronize(event) 

447 return cudaEventSynchronize(event) 

448  

449cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

450 cdef bint usePTDS = cudaPythonInit() 1 ctx1J

451 if usePTDS: 1 ctx1J

452 return ptds._cudaEventDestroy(event) 

453 return cudaEventDestroy(event) 1 ctx1J

454  

455cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

456 cdef bint usePTDS = cudaPythonInit() 

457 if usePTDS: 

458 return ptds._cudaEventElapsedTime(ms, start, end) 

459 return cudaEventElapsedTime(ms, start, end) 

460  

461cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

462 cdef bint usePTDS = cudaPythonInit() 

463 if usePTDS: 

464 return ptds._cudaImportExternalMemory(extMem_out, memHandleDesc) 

465 return cudaImportExternalMemory(extMem_out, memHandleDesc) 

466  

467cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

468 cdef bint usePTDS = cudaPythonInit() 

469 if usePTDS: 

470 return ptds._cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) 

471 return cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc) 

472  

473cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

474 cdef bint usePTDS = cudaPythonInit() 

475 if usePTDS: 

476 return ptds._cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) 

477 return cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc) 

478  

479cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

480 cdef bint usePTDS = cudaPythonInit() 

481 if usePTDS: 

482 return ptds._cudaDestroyExternalMemory(extMem) 

483 return cudaDestroyExternalMemory(extMem) 

484  

485cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

486 cdef bint usePTDS = cudaPythonInit() 

487 if usePTDS: 

488 return ptds._cudaImportExternalSemaphore(extSem_out, semHandleDesc) 

489 return cudaImportExternalSemaphore(extSem_out, semHandleDesc) 

490  

491cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

492 cdef bint usePTDS = cudaPythonInit() 

493 if usePTDS: 

494 return ptds._cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) 

495 return cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) 

496  

497cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

498 cdef bint usePTDS = cudaPythonInit() 

499 if usePTDS: 

500 return ptds._cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) 

501 return cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream) 

502  

503cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

504 cdef bint usePTDS = cudaPythonInit() 

505 if usePTDS: 

506 return ptds._cudaDestroyExternalSemaphore(extSem) 

507 return cudaDestroyExternalSemaphore(extSem) 

508  

509cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

510 cdef bint usePTDS = cudaPythonInit() 

511 if usePTDS: 

512 return ptds._cudaFuncSetCacheConfig(func, cacheConfig) 

513 return cudaFuncSetCacheConfig(func, cacheConfig) 

514  

515cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

516 cdef bint usePTDS = cudaPythonInit() 

517 if usePTDS: 

518 return ptds._cudaFuncGetAttributes(attr, func) 

519 return cudaFuncGetAttributes(attr, func) 

520  

521cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

522 cdef bint usePTDS = cudaPythonInit() 

523 if usePTDS: 

524 return ptds._cudaFuncSetAttribute(func, attr, value) 

525 return cudaFuncSetAttribute(func, attr, value) 

526  

527cdef cudaError_t _cudaFuncGetParamCount(const void* func, size_t* paramCount) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

528 cdef bint usePTDS = cudaPythonInit() 

529 if usePTDS: 

530 return ptds._cudaFuncGetParamCount(func, paramCount) 

531 return cudaFuncGetParamCount(func, paramCount) 

532  

533cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

534 cdef bint usePTDS = cudaPythonInit() 1 ctx1u

535 if usePTDS: 1 ctx1u

536 return ptds._cudaLaunchHostFunc(stream, fn, userData) 

537 return cudaLaunchHostFunc(stream, fn, userData) 1 ctx1u

538  

539cdef cudaError_t _cudaLaunchHostFunc_v2(cudaStream_t stream, cudaHostFn_t fn, void* userData, unsigned int syncMode) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

540 cdef bint usePTDS = cudaPythonInit() 

541 if usePTDS: 

542 return ptds._cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) 

543 return cudaLaunchHostFunc_v2(stream, fn, userData, syncMode) 

544  

545cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

546 cdef bint usePTDS = cudaPythonInit() 

547 if usePTDS: 

548 return ptds._cudaFuncSetSharedMemConfig(func, config) 

549 return cudaFuncSetSharedMemConfig(func, config) 

550  

551cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

552 cdef bint usePTDS = cudaPythonInit() 

553 if usePTDS: 

554 return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) 

555 return cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize) 

556  

557cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

558 cdef bint usePTDS = cudaPythonInit() 

559 if usePTDS: 

560 return ptds._cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) 

561 return cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize) 

562  

563cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

564 cdef bint usePTDS = cudaPythonInit() 

565 if usePTDS: 

566 return ptds._cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) 

567 return cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags) (empty)

568  

569cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

570 cdef bint usePTDS = cudaPythonInit() 

571 if usePTDS: 

572 return ptds._cudaMallocManaged(devPtr, size, flags) 

573 return cudaMallocManaged(devPtr, size, flags) 

574  

575cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

576 cdef bint usePTDS = cudaPythonInit() 8 ctx1fdgbchzp

577 if usePTDS: 8 ctx1fdgbchzp

578 return ptds._cudaMalloc(devPtr, size) 

579 return cudaMalloc(devPtr, size) 8 ctx1fdgbchzp

580  

581cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

582 cdef bint usePTDS = cudaPythonInit() 

583 if usePTDS: 

584 return ptds._cudaMallocHost(ptr, size) 

585 return cudaMallocHost(ptr, size) 

586  

587cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

588 cdef bint usePTDS = cudaPythonInit() 

589 if usePTDS: 

590 return ptds._cudaMallocPitch(devPtr, pitch, width, height) 

591 return cudaMallocPitch(devPtr, pitch, width, height) 

592  

593cdef cudaError_t _cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

594 cdef bint usePTDS = cudaPythonInit() 12 ctx1rskiglebcjhm

595 if usePTDS: 12 ctx1rskiglebcjhm

596 return ptds._cudaMallocArray(array, desc, width, height, flags) 

597 return cudaMallocArray(array, desc, width, height, flags) 12 ctx1rskiglebcjhm

598  

599cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

600 cdef bint usePTDS = cudaPythonInit() 10 ctx1fdgbchnozp

601 if usePTDS: 10 ctx1fdgbchnozp

602 return ptds._cudaFree(devPtr) 

603 return cudaFree(devPtr) 10 ctx1fdgbchnozp

604  

605cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

606 cdef bint usePTDS = cudaPythonInit() 5 ctx1NOPQp

607 if usePTDS: 5 ctx1NOPQp

608 return ptds._cudaFreeHost(ptr) 

609 return cudaFreeHost(ptr) 5 ctx1NOPQp

610  

611cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

612 cdef bint usePTDS = cudaPythonInit() 11 ctx1rsiglebcjhm

613 if usePTDS: 11 ctx1rsiglebcjhm

614 return ptds._cudaFreeArray(array) 

615 return cudaFreeArray(array) 11 ctx1rsiglebcjhm

616  

617cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

618 cdef bint usePTDS = cudaPythonInit() 1 ctx1x

619 if usePTDS: 1 ctx1x

620 return ptds._cudaFreeMipmappedArray(mipmappedArray) 

621 return cudaFreeMipmappedArray(mipmappedArray) 1 ctx1x

622  

623cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

624 cdef bint usePTDS = cudaPythonInit() 5 ctx1NOPQp

625 if usePTDS: 5 ctx1NOPQp

626 return ptds._cudaHostAlloc(pHost, size, flags) 

627 return cudaHostAlloc(pHost, size, flags) 5 ctx1NOPQp

628  

629cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

630 cdef bint usePTDS = cudaPythonInit() 1 ctx1D

631 if usePTDS: 1 ctx1D

632 return ptds._cudaHostRegister(ptr, size, flags) 

633 return cudaHostRegister(ptr, size, flags) 1 ctx1D

634  

635cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

636 cdef bint usePTDS = cudaPythonInit() 1 ctx1D

637 if usePTDS: 1 ctx1D

638 return ptds._cudaHostUnregister(ptr) 

639 return cudaHostUnregister(ptr) 1 ctx1D

640  

641cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

642 cdef bint usePTDS = cudaPythonInit() 

643 if usePTDS: 

644 return ptds._cudaHostGetDevicePointer(pDevice, pHost, flags) 

645 return cudaHostGetDevicePointer(pDevice, pHost, flags) 

646  

647cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

648 cdef bint usePTDS = cudaPythonInit() 

649 if usePTDS: 

650 return ptds._cudaHostGetFlags(pFlags, pHost) 

651 return cudaHostGetFlags(pFlags, pHost) 

652  

653cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

654 cdef bint usePTDS = cudaPythonInit() 2 ctx1no

655 if usePTDS: 2 ctx1no

656 return ptds._cudaMalloc3D(pitchedDevPtr, extent) 

657 return cudaMalloc3D(pitchedDevPtr, extent) 2 ctx1no

658  

659cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

660 cdef bint usePTDS = cudaPythonInit() 

661 if usePTDS: 

662 return ptds._cudaMalloc3DArray(array, desc, extent, flags) 

663 return cudaMalloc3DArray(array, desc, extent, flags) 

664  

665cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

666 cdef bint usePTDS = cudaPythonInit() 1 ctx1x

667 if usePTDS: 1 ctx1x

668 return ptds._cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) 

669 return cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags) 1 ctx1x

670  

671cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

672 cdef bint usePTDS = cudaPythonInit() 

673 if usePTDS: 

674 return ptds._cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) 

675 return cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level) 

676  

677cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

678 cdef bint usePTDS = cudaPythonInit() 

679 if usePTDS: 

680 return ptds._cudaMemcpy3D(p) 

681 return cudaMemcpy3D(p) 

682  

683cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

684 cdef bint usePTDS = cudaPythonInit() 1 ctx1c

685 if usePTDS: 1 ctx1c

686 return ptds._cudaMemcpy3DPeer(p) 

687 return cudaMemcpy3DPeer(p) 1 ctx1c

688  

689cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

690 cdef bint usePTDS = cudaPythonInit() 1 ctx1e

691 if usePTDS: 1 ctx1e

692 return ptds._cudaMemcpy3DAsync(p, stream) 

693 return cudaMemcpy3DAsync(p, stream) 1 ctx1e

694  

695cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

696 cdef bint usePTDS = cudaPythonInit() 1 ctx1b

697 if usePTDS: 1 ctx1b

698 return ptds._cudaMemcpy3DPeerAsync(p, stream) 

699 return cudaMemcpy3DPeerAsync(p, stream) 1 ctx1b

700  

701cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

702 cdef bint usePTDS = cudaPythonInit() 

703 if usePTDS: 

704 return ptds._cudaMemGetInfo(free, total) 

705 return cudaMemGetInfo(free, total) 

706  

707cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

708 cdef bint usePTDS = cudaPythonInit() 1 ctx1r

709 if usePTDS: 1 ctx1r

710 return ptds._cudaArrayGetInfo(desc, extent, flags, array) 

711 return cudaArrayGetInfo(desc, extent, flags, array) 1 ctx1r

712  

713cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

714 cdef bint usePTDS = cudaPythonInit() 

715 if usePTDS: 

716 return ptds._cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) 

717 return cudaArrayGetPlane(pPlaneArray, hArray, planeIdx) 

718  

719cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

720 cdef bint usePTDS = cudaPythonInit() 

721 if usePTDS: 

722 return ptds._cudaArrayGetMemoryRequirements(memoryRequirements, array, device) 

723 return cudaArrayGetMemoryRequirements(memoryRequirements, array, device) 

724  

725cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

726 cdef bint usePTDS = cudaPythonInit() 

727 if usePTDS: 

728 return ptds._cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) 

729 return cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device) 

730  

731cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

732 cdef bint usePTDS = cudaPythonInit() 

733 if usePTDS: 

734 return ptds._cudaArrayGetSparseProperties(sparseProperties, array) 

735 return cudaArrayGetSparseProperties(sparseProperties, array) 

736  

737cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

738 cdef bint usePTDS = cudaPythonInit() 1 ctx1x

739 if usePTDS: 1 ctx1x

740 return ptds._cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) 

741 return cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap) 1 ctx1x

742  

743cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

744 cdef bint usePTDS = cudaPythonInit() 8 ctx1gbchnozI

745 if usePTDS: 8 ctx1gbchnozI

746 return ptds._cudaMemcpy(dst, src, count, kind) 

747 return cudaMemcpy(dst, src, count, kind) 8 ctx1gbchnozI

748  

749cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

750 cdef bint usePTDS = cudaPythonInit() 

751 if usePTDS: 

752 return ptds._cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) 

753 return cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count) 

754  

755cdef 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: (empty)

756 cdef bint usePTDS = cudaPythonInit() 

757 if usePTDS: 

758 return ptds._cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) 

759 return cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind) 

760  

761cdef 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: (empty)

762 cdef bint usePTDS = cudaPythonInit() 4 ctx1iglj

763 if usePTDS: 4 ctx1iglj

764 return ptds._cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) 

765 return cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind) 4 ctx1iglj

766  

767cdef 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: (empty)

768 cdef bint usePTDS = cudaPythonInit() 7 ctx1iglebcj

769 if usePTDS: 7 ctx1iglebcj

770 return ptds._cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) 

771 return cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind) 7 ctx1iglebcj

772  

773cdef 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: (empty)

774 cdef bint usePTDS = cudaPythonInit() 1 ctx1i

775 if usePTDS: 1 ctx1i

776 return ptds._cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) 

777 return cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind) 1 ctx1i

778  

779cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

780 cdef bint usePTDS = cudaPythonInit() 1 ctx1p

781 if usePTDS: 1 ctx1p

782 return ptds._cudaMemcpyAsync(dst, src, count, kind, stream) 

783 return cudaMemcpyAsync(dst, src, count, kind, stream) 1 ctx1p

784  

785cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

786 cdef bint usePTDS = cudaPythonInit() 

787 if usePTDS: 

788 return ptds._cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) 

789 return cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream) 

790  

791cdef 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: (empty)

792 cdef bint usePTDS = cudaPythonInit() 

793 if usePTDS: 

794 return ptds._cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) 

795 return cudaMemcpyBatchAsync(dsts, srcs, sizes, count, attrs, attrsIdxs, numAttrs, stream) 

796  

797cdef cudaError_t _cudaMemcpy3DBatchAsync(size_t numOps, cudaMemcpy3DBatchOp* opList, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

798 cdef bint usePTDS = cudaPythonInit() 

799 if usePTDS: 

800 return ptds._cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) 

801 return cudaMemcpy3DBatchAsync(numOps, opList, flags, stream) 

802  

803cdef cudaError_t _cudaMemcpyWithAttributesAsync(void* dst, const void* src, size_t size, cudaMemcpyAttributes* attr, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

804 cdef bint usePTDS = cudaPythonInit() 

805 if usePTDS: 

806 return ptds._cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) 

807 return cudaMemcpyWithAttributesAsync(dst, src, size, attr, stream) 

808  

809cdef cudaError_t _cudaMemcpy3DWithAttributesAsync(cudaMemcpy3DBatchOp* op, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

810 cdef bint usePTDS = cudaPythonInit() 

811 if usePTDS: 

812 return ptds._cudaMemcpy3DWithAttributesAsync(op, flags, stream) 

813 return cudaMemcpy3DWithAttributesAsync(op, flags, stream) 

814  

815cdef 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: (empty)

816 cdef bint usePTDS = cudaPythonInit() 

817 if usePTDS: 

818 return ptds._cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) 

819 return cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream) (empty)

820  

821cdef 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: (empty)

822 cdef bint usePTDS = cudaPythonInit() 

823 if usePTDS: 

824 return ptds._cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) 

825 return cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream) 

826  

827cdef 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: (empty)

828 cdef bint usePTDS = cudaPythonInit() 

829 if usePTDS: 

830 return ptds._cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) 

831 return cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream) 

832  

833cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

834 cdef bint usePTDS = cudaPythonInit() 1 ctx1I

835 if usePTDS: 1 ctx1I

836 return ptds._cudaMemset(devPtr, value, count) 

837 return cudaMemset(devPtr, value, count) 1 ctx1I

838  

839cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

840 cdef bint usePTDS = cudaPythonInit() 

841 if usePTDS: 

842 return ptds._cudaMemset2D(devPtr, pitch, value, width, height) 

843 return cudaMemset2D(devPtr, pitch, value, width, height) 

844  

845cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

846 cdef bint usePTDS = cudaPythonInit() 2 ctx1no

847 if usePTDS: 2 ctx1no

848 return ptds._cudaMemset3D(pitchedDevPtr, value, extent) 

849 return cudaMemset3D(pitchedDevPtr, value, extent) 2 ctx1no

850  

851cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

852 cdef bint usePTDS = cudaPythonInit() 

853 if usePTDS: 

854 return ptds._cudaMemsetAsync(devPtr, value, count, stream) 

855 return cudaMemsetAsync(devPtr, value, count, stream) 

856  

857cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

858 cdef bint usePTDS = cudaPythonInit() 

859 if usePTDS: 

860 return ptds._cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) 

861 return cudaMemset2DAsync(devPtr, pitch, value, width, height, stream) 

862  

863cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

864 cdef bint usePTDS = cudaPythonInit() 

865 if usePTDS: 

866 return ptds._cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) 

867 return cudaMemset3DAsync(pitchedDevPtr, value, extent, stream) 

868  

869cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

870 cdef bint usePTDS = cudaPythonInit() 

871 if usePTDS: 

872 return ptds._cudaMemPrefetchAsync(devPtr, count, location, flags, stream) 

873 return cudaMemPrefetchAsync(devPtr, count, location, flags, stream) 

874  

875cdef 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: (empty)

876 cdef bint usePTDS = cudaPythonInit() 

877 if usePTDS: 

878 return ptds._cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) 

879 return cudaMemPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) 

880  

881cdef cudaError_t _cudaMemDiscardBatchAsync(void** dptrs, size_t* sizes, size_t count, unsigned long long flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

882 cdef bint usePTDS = cudaPythonInit() 

883 if usePTDS: 

884 return ptds._cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) 

885 return cudaMemDiscardBatchAsync(dptrs, sizes, count, flags, stream) 

886  

887cdef 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: (empty)

888 cdef bint usePTDS = cudaPythonInit() 

889 if usePTDS: 

890 return ptds._cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) 

891 return cudaMemDiscardAndPrefetchBatchAsync(dptrs, sizes, count, prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream) 

892  

893cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

894 cdef bint usePTDS = cudaPythonInit() 

895 if usePTDS: 

896 return ptds._cudaMemAdvise(devPtr, count, advice, location) 

897 return cudaMemAdvise(devPtr, count, advice, location) 

898  

899cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

900 cdef bint usePTDS = cudaPythonInit() 

901 if usePTDS: 

902 return ptds._cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) 

903 return cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count) 

904  

905cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

906 cdef bint usePTDS = cudaPythonInit() 

907 if usePTDS: 

908 return ptds._cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) 

909 return cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count) 

910  

911cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

912 cdef bint usePTDS = cudaPythonInit() 2 ctx1hm

913 if usePTDS: 2 ctx1hm

914 return ptds._cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) 

915 return cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind) 2 ctx1hm

916  

917cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

918 cdef bint usePTDS = cudaPythonInit() 2 ctx1hm

919 if usePTDS: 2 ctx1hm

920 return ptds._cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) 

921 return cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind) 2 ctx1hm

922  

923cdef 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: (empty)

924 cdef bint usePTDS = cudaPythonInit() 1 ctx1j

925 if usePTDS: 1 ctx1j

926 return ptds._cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) 

927 return cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind) 1 ctx1j

928  

929cdef 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: (empty)

930 cdef bint usePTDS = cudaPythonInit() 

931 if usePTDS: 

932 return ptds._cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) 

933 return cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream) 

934  

935cdef 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: (empty)

936 cdef bint usePTDS = cudaPythonInit() 

937 if usePTDS: 

938 return ptds._cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) 

939 return cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream) 

940  

941cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

942 cdef bint usePTDS = cudaPythonInit() 

943 if usePTDS: 

944 return ptds._cudaMallocAsync(devPtr, size, hStream) 

945 return cudaMallocAsync(devPtr, size, hStream) 

946  

947cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

948 cdef bint usePTDS = cudaPythonInit() 

949 if usePTDS: 

950 return ptds._cudaFreeAsync(devPtr, hStream) 

951 return cudaFreeAsync(devPtr, hStream) 

952  

953cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

954 cdef bint usePTDS = cudaPythonInit() 

955 if usePTDS: 

956 return ptds._cudaMemPoolTrimTo(memPool, minBytesToKeep) 

957 return cudaMemPoolTrimTo(memPool, minBytesToKeep) 

958  

959cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

960 cdef bint usePTDS = cudaPythonInit() 1 ctx1q

961 if usePTDS: 1 ctx1q

962 return ptds._cudaMemPoolSetAttribute(memPool, attr, value) 

963 return cudaMemPoolSetAttribute(memPool, attr, value) 1 ctx1q

964  

965cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

966 cdef bint usePTDS = cudaPythonInit() 1 ctx1q

967 if usePTDS: 1 ctx1q

968 return ptds._cudaMemPoolGetAttribute(memPool, attr, value) 

969 return cudaMemPoolGetAttribute(memPool, attr, value) 1 ctx1q

970  

971cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

972 cdef bint usePTDS = cudaPythonInit() 

973 if usePTDS: 

974 return ptds._cudaMemPoolSetAccess(memPool, descList, count) 

975 return cudaMemPoolSetAccess(memPool, descList, count) 

976  

977cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

978 cdef bint usePTDS = cudaPythonInit() 

979 if usePTDS: 

980 return ptds._cudaMemPoolGetAccess(flags, memPool, location) 

981 return cudaMemPoolGetAccess(flags, memPool, location) 

982  

983cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

984 cdef bint usePTDS = cudaPythonInit() 1 ctx1q

985 if usePTDS: 1 ctx1q

986 return ptds._cudaMemPoolCreate(memPool, poolProps) 

987 return cudaMemPoolCreate(memPool, poolProps) 1 ctx1q

988  

989cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

990 cdef bint usePTDS = cudaPythonInit() 1 ctx1q

991 if usePTDS: 1 ctx1q

992 return ptds._cudaMemPoolDestroy(memPool) 

993 return cudaMemPoolDestroy(memPool) 1 ctx1q

994  

995cdef cudaError_t _cudaMemGetDefaultMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

996 cdef bint usePTDS = cudaPythonInit() 

997 if usePTDS: 

998 return ptds._cudaMemGetDefaultMemPool(memPool, location, typename) 

999 return cudaMemGetDefaultMemPool(memPool, location, typename) 

1000  

1001cdef cudaError_t _cudaMemGetMemPool(cudaMemPool_t* memPool, cudaMemLocation* location, cudaMemAllocationType typename) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1002 cdef bint usePTDS = cudaPythonInit() 

1003 if usePTDS: 

1004 return ptds._cudaMemGetMemPool(memPool, location, typename) 

1005 return cudaMemGetMemPool(memPool, location, typename) 

1006  

1007cdef cudaError_t _cudaMemSetMemPool(cudaMemLocation* location, cudaMemAllocationType typename, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1008 cdef bint usePTDS = cudaPythonInit() 

1009 if usePTDS: 

1010 return ptds._cudaMemSetMemPool(location, typename, memPool) 

1011 return cudaMemSetMemPool(location, typename, memPool) 

1012  

1013cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1014 cdef bint usePTDS = cudaPythonInit() 

1015 if usePTDS: 

1016 return ptds._cudaMallocFromPoolAsync(ptr, size, memPool, stream) 

1017 return cudaMallocFromPoolAsync(ptr, size, memPool, stream) 

1018  

1019cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1020 cdef bint usePTDS = cudaPythonInit() 

1021 if usePTDS: 

1022 return ptds._cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) 

1023 return cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags) 

1024  

1025cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1026 cdef bint usePTDS = cudaPythonInit() 

1027 if usePTDS: 

1028 return ptds._cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) 

1029 return cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags) 

1030  

1031cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1032 cdef bint usePTDS = cudaPythonInit() 

1033 if usePTDS: 

1034 return ptds._cudaMemPoolExportPointer(exportData, ptr) 

1035 return cudaMemPoolExportPointer(exportData, ptr) 

1036  

1037cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1038 cdef bint usePTDS = cudaPythonInit() 

1039 if usePTDS: 

1040 return ptds._cudaMemPoolImportPointer(ptr, memPool, exportData) 

1041 return cudaMemPoolImportPointer(ptr, memPool, exportData) 

1042  

1043cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1044 cdef bint usePTDS = cudaPythonInit() 

1045 if usePTDS: 

1046 return ptds._cudaPointerGetAttributes(attributes, ptr) 

1047 return cudaPointerGetAttributes(attributes, ptr) 

1048  

1049cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1050 cdef bint usePTDS = cudaPythonInit() 

1051 if usePTDS: 

1052 return ptds._cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) 

1053 return cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice) 

1054  

1055cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1056 cdef bint usePTDS = cudaPythonInit() 

1057 if usePTDS: 

1058 return ptds._cudaDeviceEnablePeerAccess(peerDevice, flags) 

1059 return cudaDeviceEnablePeerAccess(peerDevice, flags) 

1060  

1061cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1062 cdef bint usePTDS = cudaPythonInit() 

1063 if usePTDS: 

1064 return ptds._cudaDeviceDisablePeerAccess(peerDevice) 

1065 return cudaDeviceDisablePeerAccess(peerDevice) 

1066  

1067cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1068 cdef bint usePTDS = cudaPythonInit() 2 ctx1FG

1069 if usePTDS: 2 ctx1FG

1070 return ptds._cudaGraphicsUnregisterResource(resource) 

1071 return cudaGraphicsUnregisterResource(resource) 2 ctx1FG

1072  

1073cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1074 cdef bint usePTDS = cudaPythonInit() 

1075 if usePTDS: 

1076 return ptds._cudaGraphicsResourceSetMapFlags(resource, flags) 

1077 return cudaGraphicsResourceSetMapFlags(resource, flags) 

1078  

1079cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1080 cdef bint usePTDS = cudaPythonInit() 

1081 if usePTDS: 

1082 return ptds._cudaGraphicsMapResources(count, resources, stream) 

1083 return cudaGraphicsMapResources(count, resources, stream) 

1084  

1085cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1086 cdef bint usePTDS = cudaPythonInit() 

1087 if usePTDS: 

1088 return ptds._cudaGraphicsUnmapResources(count, resources, stream) 

1089 return cudaGraphicsUnmapResources(count, resources, stream) 

1090  

1091cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1092 cdef bint usePTDS = cudaPythonInit() 

1093 if usePTDS: 

1094 return ptds._cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) 

1095 return cudaGraphicsResourceGetMappedPointer(devPtr, size, resource) 

1096  

1097cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1098 cdef bint usePTDS = cudaPythonInit() 

1099 if usePTDS: 

1100 return ptds._cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) 

1101 return cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel) 

1102  

1103cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1104 cdef bint usePTDS = cudaPythonInit() 

1105 if usePTDS: 

1106 return ptds._cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) 

1107 return cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource) 

1108  

1109cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1110 cdef bint usePTDS = cudaPythonInit() 1 ctx1s

1111 if usePTDS: 1 ctx1s

1112 return ptds._cudaGetChannelDesc(desc, array) 

1113 return cudaGetChannelDesc(desc, array) 1 ctx1s

1114@cython.show_performance_hints(False) (empty)

1115cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) except* nogil: 

1116 cdef bint usePTDS = cudaPythonInit() 13 ctx1rskiglebcjhmw

1117 if usePTDS: 13 ctx1rskiglebcjhmw

1118 return ptds._cudaCreateChannelDesc(x, y, z, w, f) 

1119 return cudaCreateChannelDesc(x, y, z, w, f) 13 ctx1rskiglebcjhmw

1120  

1121cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1122 cdef bint usePTDS = cudaPythonInit() 1 ctx1k

1123 if usePTDS: 1 ctx1k

1124 return ptds._cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) 

1125 return cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc) 1 ctx1k

1126  

1127cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1128 cdef bint usePTDS = cudaPythonInit() 1 ctx1k

1129 if usePTDS: 1 ctx1k

1130 return ptds._cudaDestroyTextureObject(texObject) 

1131 return cudaDestroyTextureObject(texObject) 1 ctx1k

1132  

1133cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1134 cdef bint usePTDS = cudaPythonInit() 

1135 if usePTDS: 

1136 return ptds._cudaGetTextureObjectResourceDesc(pResDesc, texObject) 

1137 return cudaGetTextureObjectResourceDesc(pResDesc, texObject) 

1138  

1139cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1140 cdef bint usePTDS = cudaPythonInit() 1 ctx1k

1141 if usePTDS: 1 ctx1k

1142 return ptds._cudaGetTextureObjectTextureDesc(pTexDesc, texObject) 

1143 return cudaGetTextureObjectTextureDesc(pTexDesc, texObject) 1 ctx1k

1144  

1145cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1146 cdef bint usePTDS = cudaPythonInit() 

1147 if usePTDS: 

1148 return ptds._cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) 

1149 return cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject) 

1150  

1151cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1152 cdef bint usePTDS = cudaPythonInit() 

1153 if usePTDS: 

1154 return ptds._cudaCreateSurfaceObject(pSurfObject, pResDesc) 

1155 return cudaCreateSurfaceObject(pSurfObject, pResDesc) 

1156  

1157cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1158 cdef bint usePTDS = cudaPythonInit() 

1159 if usePTDS: 

1160 return ptds._cudaDestroySurfaceObject(surfObject) 

1161 return cudaDestroySurfaceObject(surfObject) 

1162  

1163cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1164 cdef bint usePTDS = cudaPythonInit() 

1165 if usePTDS: 

1166 return ptds._cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) 

1167 return cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject) 

1168  

1169cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1170 cdef bint usePTDS = cudaPythonInit() (empty)

1171 if usePTDS: (empty)

1172 return ptds._cudaDriverGetVersion(driverVersion) 

1173 return cudaDriverGetVersion(driverVersion) (empty)

1174  

1175cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1176 cdef bint usePTDS = cudaPythonInit() 

1177 if usePTDS: 

1178 return ptds._cudaRuntimeGetVersion(runtimeVersion) 

1179 return cudaRuntimeGetVersion(runtimeVersion) 

1180  

1181cdef cudaError_t _cudaLogsRegisterCallback(cudaLogsCallback_t callbackFunc, void* userData, cudaLogsCallbackHandle* callback_out) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1182 cdef bint usePTDS = cudaPythonInit() 

1183 if usePTDS: 

1184 return ptds._cudaLogsRegisterCallback(callbackFunc, userData, callback_out) 

1185 return cudaLogsRegisterCallback(callbackFunc, userData, callback_out) 

1186  

1187cdef cudaError_t _cudaLogsUnregisterCallback(cudaLogsCallbackHandle callback) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1188 cdef bint usePTDS = cudaPythonInit() 

1189 if usePTDS: 

1190 return ptds._cudaLogsUnregisterCallback(callback) 

1191 return cudaLogsUnregisterCallback(callback) 

1192  

1193cdef cudaError_t _cudaLogsCurrent(cudaLogIterator* iterator_out, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1194 cdef bint usePTDS = cudaPythonInit() 

1195 if usePTDS: 

1196 return ptds._cudaLogsCurrent(iterator_out, flags) 

1197 return cudaLogsCurrent(iterator_out, flags) 

1198  

1199cdef cudaError_t _cudaLogsDumpToFile(cudaLogIterator* iterator, const char* pathToFile, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1200 cdef bint usePTDS = cudaPythonInit() 

1201 if usePTDS: 

1202 return ptds._cudaLogsDumpToFile(iterator, pathToFile, flags) 

1203 return cudaLogsDumpToFile(iterator, pathToFile, flags) 

1204  

1205cdef cudaError_t _cudaLogsDumpToMemory(cudaLogIterator* iterator, char* buffer, size_t* size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: (empty)

1206 cdef bint usePTDS = cudaPythonInit() 

1207 if usePTDS: