Coverage for cuda/bindings/_internal/cufile.pyx: 51.69%

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

2# 

3# SPDX-License-Identifier: Apache-2.0 

4# 

5# This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. 

6# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=73d6889e33bb56f1e0e63be7a0ba1f176c5c09e6e1adf9c4360d23335e131260 

7  

8  

9# <<<< PREAMBLE CONTENT >>>> 

10  

11cdef extern from * nogil: 

12 """ 

13 #if defined(_MSC_VER) && !defined(__clang__) 

14 #include <intrin.h> 

15 static __forceinline int atomic_int_load(int *p) { 

16 int v = *(int volatile *)p; _ReadBarrier(); return v; 

17 } 

18 static __forceinline void atomic_int_store(int *p, int v) { 

19 _WriteBarrier(); *(int volatile *)p = v; 

20 } 

21 #elif defined(__cplusplus) 

22 /* GCC/Clang __atomic builtins work in any C++ standard without headers */ 

23 static inline int atomic_int_load(int *p) { 

24 return __atomic_load_n(p, __ATOMIC_ACQUIRE); 

25 } 

26 static inline void atomic_int_store(int *p, int v) { 

27 __atomic_store_n(p, v, __ATOMIC_RELEASE); 

28 } 

29 #else 

30 #include <stdatomic.h> 

31 static inline int atomic_int_load(int *p) { 

32 return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); 

33 } 

34 static inline void atomic_int_store(int *p, int v) { 

35 atomic_store_explicit((atomic_int *)p, v, memory_order_release); 

36 } 

37 #endif 

38  

39 """ 

40 cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil 

41 cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil 

42  

43cdef extern from "<dlfcn.h>": 

44 void* _cyb_dlsym "dlsym"(void*, const char*) nogil 

45 const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" 

46  

47cimport cython as _cyb_cython 

48from libc.stdint cimport intptr_t as _cyb_intptr_t 

49  

50import threading as _cyb_threading (empty)

51  

52cdef int _cyb___py_cufile_init = 0 (empty)

53cdef dict _cyb_func_ptrs = None (empty)

54cdef object _cyb_symbol_lock = _cyb_threading.Lock() (empty)

55  

56# <<<< END OF PREAMBLE CONTENT >>>> 

57  

58from libc.stdint cimport uintptr_t 

59  

60from .utils import FunctionNotFoundError, NotSupportedError (empty)

61from cuda.pathfinder import load_nvidia_dynamic_lib (empty)

62  

63  

64############################################################################### 

65# Wrapper init 

66############################################################################### 

67  

68  

69cdef void* __cuFileHandleRegister = NULL (empty)

70cdef void* __cuFileHandleDeregister = NULL (empty)

71cdef void* __cuFileBufRegister = NULL (empty)

72cdef void* __cuFileBufDeregister = NULL (empty)

73cdef void* __cuFileRead = NULL (empty)

74cdef void* __cuFileWrite = NULL (empty)

75cdef void* __cuFileDriverOpen = NULL (empty)

76cdef void* __cuFileDriverClose = NULL (empty)

77cdef void* __cuFileDriverClose_v2 = NULL (empty)

78cdef void* __cuFileUseCount = NULL (empty)

79cdef void* __cuFileDriverGetProperties = NULL (empty)

80cdef void* __cuFileDriverSetPollMode = NULL (empty)

81cdef void* __cuFileDriverSetMaxDirectIOSize = NULL (empty)

82cdef void* __cuFileDriverSetMaxCacheSize = NULL (empty)

83cdef void* __cuFileDriverSetMaxPinnedMemSize = NULL (empty)

84cdef void* __cuFileBatchIOSetUp = NULL (empty)

85cdef void* __cuFileBatchIOSubmit = NULL (empty)

86cdef void* __cuFileBatchIOGetStatus = NULL (empty)

87cdef void* __cuFileBatchIOCancel = NULL (empty)

88cdef void* __cuFileBatchIODestroy = NULL (empty)

89cdef void* __cuFileReadAsync = NULL (empty)

90cdef void* __cuFileWriteAsync = NULL (empty)

91cdef void* __cuFileStreamRegister = NULL (empty)

92cdef void* __cuFileStreamDeregister = NULL (empty)

93cdef void* __cuFileGetVersion = NULL (empty)

94cdef void* __cuFileGetParameterSizeT = NULL (empty)

95cdef void* __cuFileGetParameterBool = NULL (empty)

96cdef void* __cuFileGetParameterString = NULL (empty)

97cdef void* __cuFileSetParameterSizeT = NULL (empty)

98cdef void* __cuFileSetParameterBool = NULL (empty)

99cdef void* __cuFileSetParameterString = NULL (empty)

100cdef void* __cuFileGetParameterMinMaxValue = NULL (empty)

101cdef void* __cuFileSetStatsLevel = NULL (empty)

102cdef void* __cuFileGetStatsLevel = NULL (empty)

103cdef void* __cuFileStatsStart = NULL (empty)

104cdef void* __cuFileStatsStop = NULL (empty)

105cdef void* __cuFileStatsReset = NULL (empty)

106cdef void* __cuFileGetStatsL1 = NULL (empty)

107cdef void* __cuFileGetStatsL2 = NULL (empty)

108cdef void* __cuFileGetStatsL3 = NULL (empty)

109cdef void* __cuFileGetBARSizeInKB = NULL (empty)

110cdef void* __cuFileSetParameterPosixPoolSlabArray = NULL (empty)

111cdef void* __cuFileGetParameterPosixPoolSlabArray = NULL (empty)

112  

113cdef int _init_cufile() except -1 nogil: (empty)

114 global _cyb___py_cufile_init 

115 cdef void* handle = NULL (empty)

116 with gil, _cyb_symbol_lock: (empty)

117 if _cyb___py_cufile_init: return 0 (empty)

118  

119 global __cuFileHandleRegister 

120 __cuFileHandleRegister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileHandleRegister') (empty)

121 if __cuFileHandleRegister == NULL: (empty)

122 if handle == NULL: (empty)

123 handle = load_library() (empty)

124 __cuFileHandleRegister = _cyb_dlsym(handle, 'cuFileHandleRegister') (empty)

125  

126 global __cuFileHandleDeregister 

127 __cuFileHandleDeregister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileHandleDeregister') (empty)

128 if __cuFileHandleDeregister == NULL: (empty)

129 if handle == NULL: 

130 handle = load_library() 

131 __cuFileHandleDeregister = _cyb_dlsym(handle, 'cuFileHandleDeregister') 

132  

133 global __cuFileBufRegister 

134 __cuFileBufRegister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBufRegister') (empty)

135 if __cuFileBufRegister == NULL: (empty)

136 if handle == NULL: 

137 handle = load_library() 

138 __cuFileBufRegister = _cyb_dlsym(handle, 'cuFileBufRegister') 

139  

140 global __cuFileBufDeregister 

141 __cuFileBufDeregister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBufDeregister') (empty)

142 if __cuFileBufDeregister == NULL: (empty)

143 if handle == NULL: 

144 handle = load_library() 

145 __cuFileBufDeregister = _cyb_dlsym(handle, 'cuFileBufDeregister') 

146  

147 global __cuFileRead 

148 __cuFileRead = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileRead') (empty)

149 if __cuFileRead == NULL: (empty)

150 if handle == NULL: 

151 handle = load_library() 

152 __cuFileRead = _cyb_dlsym(handle, 'cuFileRead') 

153  

154 global __cuFileWrite 

155 __cuFileWrite = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileWrite') (empty)

156 if __cuFileWrite == NULL: (empty)

157 if handle == NULL: 

158 handle = load_library() 

159 __cuFileWrite = _cyb_dlsym(handle, 'cuFileWrite') 

160  

161 global __cuFileDriverOpen 

162 __cuFileDriverOpen = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverOpen') (empty)

163 if __cuFileDriverOpen == NULL: (empty)

164 if handle == NULL: 

165 handle = load_library() 

166 __cuFileDriverOpen = _cyb_dlsym(handle, 'cuFileDriverOpen') 

167  

168 global __cuFileDriverClose 

169 __cuFileDriverClose = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverClose') (empty)

170 if __cuFileDriverClose == NULL: (empty)

171 if handle == NULL: 

172 handle = load_library() 

173 __cuFileDriverClose = _cyb_dlsym(handle, 'cuFileDriverClose') 

174  

175 global __cuFileDriverClose_v2 

176 __cuFileDriverClose_v2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverClose_v2') (empty)

177 if __cuFileDriverClose_v2 == NULL: (empty)

178 if handle == NULL: 

179 handle = load_library() 

180 __cuFileDriverClose_v2 = _cyb_dlsym(handle, 'cuFileDriverClose_v2') 

181  

182 global __cuFileUseCount 

183 __cuFileUseCount = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileUseCount') (empty)

184 if __cuFileUseCount == NULL: (empty)

185 if handle == NULL: 

186 handle = load_library() 

187 __cuFileUseCount = _cyb_dlsym(handle, 'cuFileUseCount') 

188  

189 global __cuFileDriverGetProperties 

190 __cuFileDriverGetProperties = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverGetProperties') (empty)

191 if __cuFileDriverGetProperties == NULL: (empty)

192 if handle == NULL: 

193 handle = load_library() 

194 __cuFileDriverGetProperties = _cyb_dlsym(handle, 'cuFileDriverGetProperties') 

195  

196 global __cuFileDriverSetPollMode 

197 __cuFileDriverSetPollMode = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverSetPollMode') (empty)

198 if __cuFileDriverSetPollMode == NULL: (empty)

199 if handle == NULL: 

200 handle = load_library() 

201 __cuFileDriverSetPollMode = _cyb_dlsym(handle, 'cuFileDriverSetPollMode') 

202  

203 global __cuFileDriverSetMaxDirectIOSize 

204 __cuFileDriverSetMaxDirectIOSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverSetMaxDirectIOSize') (empty)

205 if __cuFileDriverSetMaxDirectIOSize == NULL: (empty)

206 if handle == NULL: 

207 handle = load_library() 

208 __cuFileDriverSetMaxDirectIOSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxDirectIOSize') 

209  

210 global __cuFileDriverSetMaxCacheSize 

211 __cuFileDriverSetMaxCacheSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverSetMaxCacheSize') (empty)

212 if __cuFileDriverSetMaxCacheSize == NULL: (empty)

213 if handle == NULL: 

214 handle = load_library() 

215 __cuFileDriverSetMaxCacheSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxCacheSize') 

216  

217 global __cuFileDriverSetMaxPinnedMemSize 

218 __cuFileDriverSetMaxPinnedMemSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileDriverSetMaxPinnedMemSize') (empty)

219 if __cuFileDriverSetMaxPinnedMemSize == NULL: (empty)

220 if handle == NULL: 

221 handle = load_library() 

222 __cuFileDriverSetMaxPinnedMemSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxPinnedMemSize') 

223  

224 global __cuFileBatchIOSetUp 

225 __cuFileBatchIOSetUp = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIOSetUp') (empty)

226 if __cuFileBatchIOSetUp == NULL: (empty)

227 if handle == NULL: 

228 handle = load_library() 

229 __cuFileBatchIOSetUp = _cyb_dlsym(handle, 'cuFileBatchIOSetUp') 

230  

231 global __cuFileBatchIOSubmit 

232 __cuFileBatchIOSubmit = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIOSubmit') (empty)

233 if __cuFileBatchIOSubmit == NULL: (empty)

234 if handle == NULL: 

235 handle = load_library() 

236 __cuFileBatchIOSubmit = _cyb_dlsym(handle, 'cuFileBatchIOSubmit') 

237  

238 global __cuFileBatchIOGetStatus 

239 __cuFileBatchIOGetStatus = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIOGetStatus') (empty)

240 if __cuFileBatchIOGetStatus == NULL: (empty)

241 if handle == NULL: 

242 handle = load_library() 

243 __cuFileBatchIOGetStatus = _cyb_dlsym(handle, 'cuFileBatchIOGetStatus') 

244  

245 global __cuFileBatchIOCancel 

246 __cuFileBatchIOCancel = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIOCancel') (empty)

247 if __cuFileBatchIOCancel == NULL: (empty)

248 if handle == NULL: 

249 handle = load_library() 

250 __cuFileBatchIOCancel = _cyb_dlsym(handle, 'cuFileBatchIOCancel') 

251  

252 global __cuFileBatchIODestroy 

253 __cuFileBatchIODestroy = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileBatchIODestroy') (empty)

254 if __cuFileBatchIODestroy == NULL: (empty)

255 if handle == NULL: 

256 handle = load_library() 

257 __cuFileBatchIODestroy = _cyb_dlsym(handle, 'cuFileBatchIODestroy') 

258  

259 global __cuFileReadAsync 

260 __cuFileReadAsync = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileReadAsync') (empty)

261 if __cuFileReadAsync == NULL: (empty)

262 if handle == NULL: 

263 handle = load_library() 

264 __cuFileReadAsync = _cyb_dlsym(handle, 'cuFileReadAsync') 

265  

266 global __cuFileWriteAsync 

267 __cuFileWriteAsync = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileWriteAsync') (empty)

268 if __cuFileWriteAsync == NULL: (empty)

269 if handle == NULL: 

270 handle = load_library() 

271 __cuFileWriteAsync = _cyb_dlsym(handle, 'cuFileWriteAsync') 

272  

273 global __cuFileStreamRegister 

274 __cuFileStreamRegister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStreamRegister') (empty)

275 if __cuFileStreamRegister == NULL: (empty)

276 if handle == NULL: 

277 handle = load_library() 

278 __cuFileStreamRegister = _cyb_dlsym(handle, 'cuFileStreamRegister') 

279  

280 global __cuFileStreamDeregister 

281 __cuFileStreamDeregister = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStreamDeregister') (empty)

282 if __cuFileStreamDeregister == NULL: (empty)

283 if handle == NULL: 

284 handle = load_library() 

285 __cuFileStreamDeregister = _cyb_dlsym(handle, 'cuFileStreamDeregister') 

286  

287 global __cuFileGetVersion 

288 __cuFileGetVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetVersion') (empty)

289 if __cuFileGetVersion == NULL: (empty)

290 if handle == NULL: 

291 handle = load_library() 

292 __cuFileGetVersion = _cyb_dlsym(handle, 'cuFileGetVersion') 

293  

294 global __cuFileGetParameterSizeT 

295 __cuFileGetParameterSizeT = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterSizeT') (empty)

296 if __cuFileGetParameterSizeT == NULL: (empty)

297 if handle == NULL: 

298 handle = load_library() 

299 __cuFileGetParameterSizeT = _cyb_dlsym(handle, 'cuFileGetParameterSizeT') 

300  

301 global __cuFileGetParameterBool 

302 __cuFileGetParameterBool = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterBool') (empty)

303 if __cuFileGetParameterBool == NULL: (empty)

304 if handle == NULL: 

305 handle = load_library() 

306 __cuFileGetParameterBool = _cyb_dlsym(handle, 'cuFileGetParameterBool') 

307  

308 global __cuFileGetParameterString 

309 __cuFileGetParameterString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterString') (empty)

310 if __cuFileGetParameterString == NULL: (empty)

311 if handle == NULL: 

312 handle = load_library() 

313 __cuFileGetParameterString = _cyb_dlsym(handle, 'cuFileGetParameterString') 

314  

315 global __cuFileSetParameterSizeT 

316 __cuFileSetParameterSizeT = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetParameterSizeT') (empty)

317 if __cuFileSetParameterSizeT == NULL: (empty)

318 if handle == NULL: 

319 handle = load_library() 

320 __cuFileSetParameterSizeT = _cyb_dlsym(handle, 'cuFileSetParameterSizeT') 

321  

322 global __cuFileSetParameterBool 

323 __cuFileSetParameterBool = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetParameterBool') (empty)

324 if __cuFileSetParameterBool == NULL: (empty)

325 if handle == NULL: 

326 handle = load_library() 

327 __cuFileSetParameterBool = _cyb_dlsym(handle, 'cuFileSetParameterBool') 

328  

329 global __cuFileSetParameterString 

330 __cuFileSetParameterString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetParameterString') (empty)

331 if __cuFileSetParameterString == NULL: (empty)

332 if handle == NULL: 

333 handle = load_library() 

334 __cuFileSetParameterString = _cyb_dlsym(handle, 'cuFileSetParameterString') 

335  

336 global __cuFileGetParameterMinMaxValue 

337 __cuFileGetParameterMinMaxValue = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterMinMaxValue') (empty)

338 if __cuFileGetParameterMinMaxValue == NULL: (empty)

339 if handle == NULL: 

340 handle = load_library() 

341 __cuFileGetParameterMinMaxValue = _cyb_dlsym(handle, 'cuFileGetParameterMinMaxValue') 

342  

343 global __cuFileSetStatsLevel 

344 __cuFileSetStatsLevel = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetStatsLevel') (empty)

345 if __cuFileSetStatsLevel == NULL: (empty)

346 if handle == NULL: 

347 handle = load_library() 

348 __cuFileSetStatsLevel = _cyb_dlsym(handle, 'cuFileSetStatsLevel') 

349  

350 global __cuFileGetStatsLevel 

351 __cuFileGetStatsLevel = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetStatsLevel') (empty)

352 if __cuFileGetStatsLevel == NULL: (empty)

353 if handle == NULL: 

354 handle = load_library() 

355 __cuFileGetStatsLevel = _cyb_dlsym(handle, 'cuFileGetStatsLevel') 

356  

357 global __cuFileStatsStart 

358 __cuFileStatsStart = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStatsStart') (empty)

359 if __cuFileStatsStart == NULL: (empty)

360 if handle == NULL: 

361 handle = load_library() 

362 __cuFileStatsStart = _cyb_dlsym(handle, 'cuFileStatsStart') 

363  

364 global __cuFileStatsStop 

365 __cuFileStatsStop = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStatsStop') (empty)

366 if __cuFileStatsStop == NULL: (empty)

367 if handle == NULL: 

368 handle = load_library() 

369 __cuFileStatsStop = _cyb_dlsym(handle, 'cuFileStatsStop') 

370  

371 global __cuFileStatsReset 

372 __cuFileStatsReset = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileStatsReset') (empty)

373 if __cuFileStatsReset == NULL: (empty)

374 if handle == NULL: 

375 handle = load_library() 

376 __cuFileStatsReset = _cyb_dlsym(handle, 'cuFileStatsReset') 

377  

378 global __cuFileGetStatsL1 

379 __cuFileGetStatsL1 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetStatsL1') (empty)

380 if __cuFileGetStatsL1 == NULL: (empty)

381 if handle == NULL: 

382 handle = load_library() 

383 __cuFileGetStatsL1 = _cyb_dlsym(handle, 'cuFileGetStatsL1') 

384  

385 global __cuFileGetStatsL2 

386 __cuFileGetStatsL2 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetStatsL2') (empty)

387 if __cuFileGetStatsL2 == NULL: (empty)

388 if handle == NULL: 

389 handle = load_library() 

390 __cuFileGetStatsL2 = _cyb_dlsym(handle, 'cuFileGetStatsL2') 

391  

392 global __cuFileGetStatsL3 

393 __cuFileGetStatsL3 = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetStatsL3') (empty)

394 if __cuFileGetStatsL3 == NULL: (empty)

395 if handle == NULL: 

396 handle = load_library() 

397 __cuFileGetStatsL3 = _cyb_dlsym(handle, 'cuFileGetStatsL3') 

398  

399 global __cuFileGetBARSizeInKB 

400 __cuFileGetBARSizeInKB = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetBARSizeInKB') (empty)

401 if __cuFileGetBARSizeInKB == NULL: (empty)

402 if handle == NULL: 

403 handle = load_library() 

404 __cuFileGetBARSizeInKB = _cyb_dlsym(handle, 'cuFileGetBARSizeInKB') 

405  

406 global __cuFileSetParameterPosixPoolSlabArray 

407 __cuFileSetParameterPosixPoolSlabArray = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileSetParameterPosixPoolSlabArray') (empty)

408 if __cuFileSetParameterPosixPoolSlabArray == NULL: (empty)

409 if handle == NULL: 

410 handle = load_library() 

411 __cuFileSetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileSetParameterPosixPoolSlabArray') 

412  

413 global __cuFileGetParameterPosixPoolSlabArray 

414 __cuFileGetParameterPosixPoolSlabArray = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileGetParameterPosixPoolSlabArray') (empty)

415 if __cuFileGetParameterPosixPoolSlabArray == NULL: (empty)

416 if handle == NULL: 

417 handle = load_library() 

418 __cuFileGetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileGetParameterPosixPoolSlabArray') 

419  

420 _cyb_atomic_int_store(<int *>&_cyb___py_cufile_init, 1) (empty)

421 return 0 (empty)

422  

423cdef inline int _check_or_init_cufile() except -1 nogil: (empty)

424 if _cyb_atomic_int_load(<int *>&_cyb___py_cufile_init): 76 ctx1aeMNfOPgQRxSTyUVzWXAYZB01C23h45i67k89l!#m$%j'()D*+,-bEqcFrdGsH./noptI:JKuvLw

425 return 0 76 ctx1aeMNfOPgQRxSTyUVzWXAYZB01C23h45i67k89l!#m$%j'()D*+,-bEqcFrdGsH./noptI:JKuvLw

426  

427 return _init_cufile() (empty)

428  

429  

430cpdef dict _inspect_function_pointers(): (empty)

431 global _cyb_func_ptrs 

432 if _cyb_func_ptrs is not None: 

433 return _cyb_func_ptrs 

434  

435 _check_or_init_cufile() 

436 cdef dict data = {} 

437 global __cuFileHandleRegister 

438 data["__cuFileHandleRegister"] = <_cyb_intptr_t>__cuFileHandleRegister 

439  

440 global __cuFileHandleDeregister 

441 data["__cuFileHandleDeregister"] = <_cyb_intptr_t>__cuFileHandleDeregister 

442  

443 global __cuFileBufRegister 

444 data["__cuFileBufRegister"] = <_cyb_intptr_t>__cuFileBufRegister 

445  

446 global __cuFileBufDeregister 

447 data["__cuFileBufDeregister"] = <_cyb_intptr_t>__cuFileBufDeregister 

448  

449 global __cuFileRead 

450 data["__cuFileRead"] = <_cyb_intptr_t>__cuFileRead 

451  

452 global __cuFileWrite 

453 data["__cuFileWrite"] = <_cyb_intptr_t>__cuFileWrite 

454  

455 global __cuFileDriverOpen 

456 data["__cuFileDriverOpen"] = <_cyb_intptr_t>__cuFileDriverOpen 

457  

458 global __cuFileDriverClose 

459 data["__cuFileDriverClose"] = <_cyb_intptr_t>__cuFileDriverClose 

460  

461 global __cuFileDriverClose_v2 

462 data["__cuFileDriverClose_v2"] = <_cyb_intptr_t>__cuFileDriverClose_v2 

463  

464 global __cuFileUseCount 

465 data["__cuFileUseCount"] = <_cyb_intptr_t>__cuFileUseCount 

466  

467 global __cuFileDriverGetProperties 

468 data["__cuFileDriverGetProperties"] = <_cyb_intptr_t>__cuFileDriverGetProperties 

469  

470 global __cuFileDriverSetPollMode 

471 data["__cuFileDriverSetPollMode"] = <_cyb_intptr_t>__cuFileDriverSetPollMode 

472  

473 global __cuFileDriverSetMaxDirectIOSize 

474 data["__cuFileDriverSetMaxDirectIOSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxDirectIOSize 

475  

476 global __cuFileDriverSetMaxCacheSize 

477 data["__cuFileDriverSetMaxCacheSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxCacheSize 

478  

479 global __cuFileDriverSetMaxPinnedMemSize 

480 data["__cuFileDriverSetMaxPinnedMemSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxPinnedMemSize 

481  

482 global __cuFileBatchIOSetUp 

483 data["__cuFileBatchIOSetUp"] = <_cyb_intptr_t>__cuFileBatchIOSetUp 

484  

485 global __cuFileBatchIOSubmit 

486 data["__cuFileBatchIOSubmit"] = <_cyb_intptr_t>__cuFileBatchIOSubmit 

487  

488 global __cuFileBatchIOGetStatus 

489 data["__cuFileBatchIOGetStatus"] = <_cyb_intptr_t>__cuFileBatchIOGetStatus 

490  

491 global __cuFileBatchIOCancel 

492 data["__cuFileBatchIOCancel"] = <_cyb_intptr_t>__cuFileBatchIOCancel 

493  

494 global __cuFileBatchIODestroy 

495 data["__cuFileBatchIODestroy"] = <_cyb_intptr_t>__cuFileBatchIODestroy 

496  

497 global __cuFileReadAsync 

498 data["__cuFileReadAsync"] = <_cyb_intptr_t>__cuFileReadAsync 

499  

500 global __cuFileWriteAsync 

501 data["__cuFileWriteAsync"] = <_cyb_intptr_t>__cuFileWriteAsync 

502  

503 global __cuFileStreamRegister 

504 data["__cuFileStreamRegister"] = <_cyb_intptr_t>__cuFileStreamRegister 

505  

506 global __cuFileStreamDeregister 

507 data["__cuFileStreamDeregister"] = <_cyb_intptr_t>__cuFileStreamDeregister 

508  

509 global __cuFileGetVersion 

510 data["__cuFileGetVersion"] = <_cyb_intptr_t>__cuFileGetVersion 

511  

512 global __cuFileGetParameterSizeT 

513 data["__cuFileGetParameterSizeT"] = <_cyb_intptr_t>__cuFileGetParameterSizeT 

514  

515 global __cuFileGetParameterBool 

516 data["__cuFileGetParameterBool"] = <_cyb_intptr_t>__cuFileGetParameterBool 

517  

518 global __cuFileGetParameterString 

519 data["__cuFileGetParameterString"] = <_cyb_intptr_t>__cuFileGetParameterString 

520  

521 global __cuFileSetParameterSizeT 

522 data["__cuFileSetParameterSizeT"] = <_cyb_intptr_t>__cuFileSetParameterSizeT 

523  

524 global __cuFileSetParameterBool 

525 data["__cuFileSetParameterBool"] = <_cyb_intptr_t>__cuFileSetParameterBool 

526  

527 global __cuFileSetParameterString 

528 data["__cuFileSetParameterString"] = <_cyb_intptr_t>__cuFileSetParameterString 

529  

530 global __cuFileGetParameterMinMaxValue 

531 data["__cuFileGetParameterMinMaxValue"] = <_cyb_intptr_t>__cuFileGetParameterMinMaxValue 

532  

533 global __cuFileSetStatsLevel 

534 data["__cuFileSetStatsLevel"] = <_cyb_intptr_t>__cuFileSetStatsLevel 

535  

536 global __cuFileGetStatsLevel 

537 data["__cuFileGetStatsLevel"] = <_cyb_intptr_t>__cuFileGetStatsLevel 

538  

539 global __cuFileStatsStart 

540 data["__cuFileStatsStart"] = <_cyb_intptr_t>__cuFileStatsStart 

541  

542 global __cuFileStatsStop 

543 data["__cuFileStatsStop"] = <_cyb_intptr_t>__cuFileStatsStop 

544  

545 global __cuFileStatsReset 

546 data["__cuFileStatsReset"] = <_cyb_intptr_t>__cuFileStatsReset 

547  

548 global __cuFileGetStatsL1 

549 data["__cuFileGetStatsL1"] = <_cyb_intptr_t>__cuFileGetStatsL1 

550  

551 global __cuFileGetStatsL2 

552 data["__cuFileGetStatsL2"] = <_cyb_intptr_t>__cuFileGetStatsL2 

553  

554 global __cuFileGetStatsL3 

555 data["__cuFileGetStatsL3"] = <_cyb_intptr_t>__cuFileGetStatsL3 

556  

557 global __cuFileGetBARSizeInKB 

558 data["__cuFileGetBARSizeInKB"] = <_cyb_intptr_t>__cuFileGetBARSizeInKB 

559  

560 global __cuFileSetParameterPosixPoolSlabArray 

561 data["__cuFileSetParameterPosixPoolSlabArray"] = <_cyb_intptr_t>__cuFileSetParameterPosixPoolSlabArray 

562  

563 global __cuFileGetParameterPosixPoolSlabArray 

564 data["__cuFileGetParameterPosixPoolSlabArray"] = <_cyb_intptr_t>__cuFileGetParameterPosixPoolSlabArray 

565 _cyb_func_ptrs = data 

566 return data 

567  

568  

569cpdef _inspect_function_pointer(str name): (empty)

570 global _cyb_func_ptrs 

571 if _cyb_func_ptrs is None: 

572 _cyb_func_ptrs = _inspect_function_pointers() 

573 return _cyb_func_ptrs[name] 

574  

575  

576  

577  

578cdef void* load_library() except* with gil: (empty)

579 cdef uintptr_t handle = load_nvidia_dynamic_lib("cufile")._handle_uint (empty)

580 return <void*>handle (empty)

581  

582  

583############################################################################### 

584# Wrapper functions 

585  

586cdef CUfileError_t _cuFileHandleRegister(CUfileHandle_t* fh, CUfileDescr_t* descr) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

587 global __cuFileHandleRegister 

588 _check_or_init_cufile() 13 ctx1efghiklmjbcdH

589 if __cuFileHandleRegister == NULL: 13 ctx1efghiklmjbcdH

590 with gil: 

591 raise FunctionNotFoundError("function cuFileHandleRegister is not found") 

592 return (<CUfileError_t (*)(CUfileHandle_t*, CUfileDescr_t*) noexcept nogil>__cuFileHandleRegister)( 13 ctx1efghiklmjbcdH

593 fh, descr) 

594  

595  

596@_cyb_cython.show_performance_hints(False) (empty)

597cdef void _cuFileHandleDeregister(CUfileHandle_t fh) except* nogil: 

598 global __cuFileHandleDeregister 

599 _check_or_init_cufile() 13 ctx1efghiklmjbcdH

600 if __cuFileHandleDeregister == NULL: 13 ctx1efghiklmjbcdH

601 with gil: 

602 raise FunctionNotFoundError("function cuFileHandleDeregister is not found") 

603 (<void (*)(CUfileHandle_t) noexcept nogil>__cuFileHandleDeregister)( 13 ctx1efghiklmjbcdH

604 fh) 

605  

606  

607cdef CUfileError_t _cuFileBufRegister(const void* bufPtr_base, size_t length, int flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

608 global __cuFileBufRegister 

609 _check_or_init_cufile() 18 ctx1efgxyzABChiklmjbcd

610 if __cuFileBufRegister == NULL: 18 ctx1efgxyzABChiklmjbcd

611 with gil: 

612 raise FunctionNotFoundError("function cuFileBufRegister is not found") 

613 return (<CUfileError_t (*)(const void*, size_t, int) noexcept nogil>__cuFileBufRegister)( 18 ctx1efgxyzABChiklmjbcd

614 bufPtr_base, length, flags) 

615  

616  

617cdef CUfileError_t _cuFileBufDeregister(const void* bufPtr_base) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

618 global __cuFileBufDeregister 

619 _check_or_init_cufile() 18 ctx1efgxyzABChiklmjbcd

620 if __cuFileBufDeregister == NULL: 18 ctx1efgxyzABChiklmjbcd

621 with gil: 

622 raise FunctionNotFoundError("function cuFileBufDeregister is not found") 

623 return (<CUfileError_t (*)(const void*) noexcept nogil>__cuFileBufDeregister)( 18 ctx1efgxyzABChiklmjbcd

624 bufPtr_base) 

625  

626  

627cdef ssize_t _cuFileRead(CUfileHandle_t fh, void* bufPtr_base, size_t size, off_t file_offset, off_t bufPtr_offset) except* nogil: (empty)

628 global __cuFileRead 

629 _check_or_init_cufile() 6 ctx1klmbcd

630 if __cuFileRead == NULL: 6 ctx1klmbcd

631 with gil: 

632 raise FunctionNotFoundError("function cuFileRead is not found") 

633 return (<ssize_t (*)(CUfileHandle_t, void*, size_t, off_t, off_t) noexcept nogil>__cuFileRead)( 6 ctx1klmbcd

634 fh, bufPtr_base, size, file_offset, bufPtr_offset) 

635  

636  

637cdef ssize_t _cuFileWrite(CUfileHandle_t fh, const void* bufPtr_base, size_t size, off_t file_offset, off_t bufPtr_offset) except* nogil: (empty)

638 global __cuFileWrite 

639 _check_or_init_cufile() 6 ctx1klmbcd

640 if __cuFileWrite == NULL: 6 ctx1klmbcd

641 with gil: 

642 raise FunctionNotFoundError("function cuFileWrite is not found") 

643 return (<ssize_t (*)(CUfileHandle_t, const void*, size_t, off_t, off_t) noexcept nogil>__cuFileWrite)( 6 ctx1klmbcd

644 fh, bufPtr_base, size, file_offset, bufPtr_offset) 

645  

646  

647cdef CUfileError_t _cuFileDriverOpen() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

648 global __cuFileDriverOpen 

649 _check_or_init_cufile() 28 ctx1MOQSUWY02468!$'D,EFG.noptIKL

650 if __cuFileDriverOpen == NULL: 28 ctx1MOQSUWY02468!$'D,EFG.noptIKL

651 with gil: 

652 raise FunctionNotFoundError("function cuFileDriverOpen is not found") 

653 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverOpen)( 28 ctx1MOQSUWY02468!$'D,EFG.noptIKL

654 ) 

655  

656  

657cdef CUfileError_t _cuFileDriverClose() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

658 global __cuFileDriverClose 

659 _check_or_init_cufile() 

660 if __cuFileDriverClose == NULL: 

661 with gil: 

662 raise FunctionNotFoundError("function cuFileDriverClose is not found") 

663 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverClose)( 

664 ) 

665  

666  

667cdef CUfileError_t _cuFileDriverClose_v2() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

668 global __cuFileDriverClose_v2 

669 _check_or_init_cufile() 29 ctx1NPRTVXZ13579#%(D*-qrs/nopt:uw

670 if __cuFileDriverClose_v2 == NULL: 29 ctx1NPRTVXZ13579#%(D*-qrs/nopt:uw

671 with gil: 

672 raise FunctionNotFoundError("function cuFileDriverClose_v2 is not found") 

673 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverClose_v2)( 29 ctx1NPRTVXZ13579#%(D*-qrs/nopt:uw

674 ) 

675  

676  

677cdef long _cuFileUseCount() except* nogil: (empty)

678 global __cuFileUseCount 

679 _check_or_init_cufile() 

680 if __cuFileUseCount == NULL: 

681 with gil: 

682 raise FunctionNotFoundError("function cuFileUseCount is not found") 

683 return (<long (*)() noexcept nogil>__cuFileUseCount)( 

684 ) 

685  

686  

687cdef CUfileError_t _cuFileDriverGetProperties(CUfileDrvProps_t* props) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

688 global __cuFileDriverGetProperties 

689 _check_or_init_cufile() 

690 if __cuFileDriverGetProperties == NULL: 

691 with gil: 

692 raise FunctionNotFoundError("function cuFileDriverGetProperties is not found") 

693 return (<CUfileError_t (*)(CUfileDrvProps_t*) noexcept nogil>__cuFileDriverGetProperties)( 

694 props) 

695  

696  

697cdef CUfileError_t _cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

698 global __cuFileDriverSetPollMode 

699 _check_or_init_cufile() 

700 if __cuFileDriverSetPollMode == NULL: 

701 with gil: 

702 raise FunctionNotFoundError("function cuFileDriverSetPollMode is not found") 

703 return (<CUfileError_t (*)(cpp_bool, size_t) noexcept nogil>__cuFileDriverSetPollMode)( 

704 poll, poll_threshold_size) 

705  

706  

707cdef CUfileError_t _cuFileDriverSetMaxDirectIOSize(size_t max_direct_io_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

708 global __cuFileDriverSetMaxDirectIOSize 

709 _check_or_init_cufile() 

710 if __cuFileDriverSetMaxDirectIOSize == NULL: 

711 with gil: 

712 raise FunctionNotFoundError("function cuFileDriverSetMaxDirectIOSize is not found") 

713 return (<CUfileError_t (*)(size_t) noexcept nogil>__cuFileDriverSetMaxDirectIOSize)( 

714 max_direct_io_size) 

715  

716  

717cdef CUfileError_t _cuFileDriverSetMaxCacheSize(size_t max_cache_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

718 global __cuFileDriverSetMaxCacheSize 

719 _check_or_init_cufile() 

720 if __cuFileDriverSetMaxCacheSize == NULL: 

721 with gil: 

722 raise FunctionNotFoundError("function cuFileDriverSetMaxCacheSize is not found") 

723 return (<CUfileError_t (*)(size_t) noexcept nogil>__cuFileDriverSetMaxCacheSize)( 

724 max_cache_size) 

725  

726  

727cdef CUfileError_t _cuFileDriverSetMaxPinnedMemSize(size_t max_pinned_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

728 global __cuFileDriverSetMaxPinnedMemSize 

729 _check_or_init_cufile() 

730 if __cuFileDriverSetMaxPinnedMemSize == NULL: 

731 with gil: 

732 raise FunctionNotFoundError("function cuFileDriverSetMaxPinnedMemSize is not found") 

733 return (<CUfileError_t (*)(size_t) noexcept nogil>__cuFileDriverSetMaxPinnedMemSize)( 

734 max_pinned_size) 

735  

736  

737cdef CUfileError_t _cuFileBatchIOSetUp(CUfileBatchHandle_t* batch_idp, unsigned nr) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

738 global __cuFileBatchIOSetUp 

739 _check_or_init_cufile() 3 ctx1efg

740 if __cuFileBatchIOSetUp == NULL: 3 ctx1efg

741 with gil: 

742 raise FunctionNotFoundError("function cuFileBatchIOSetUp is not found") 

743 return (<CUfileError_t (*)(CUfileBatchHandle_t*, unsigned) noexcept nogil>__cuFileBatchIOSetUp)( 3 ctx1efg

744 batch_idp, nr) 

745  

746  

747cdef CUfileError_t _cuFileBatchIOSubmit(CUfileBatchHandle_t batch_idp, unsigned nr, CUfileIOParams_t* iocbp, unsigned int flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

748 global __cuFileBatchIOSubmit 

749 _check_or_init_cufile() 3 ctx1efg

750 if __cuFileBatchIOSubmit == NULL: 3 ctx1efg

751 with gil: 

752 raise FunctionNotFoundError("function cuFileBatchIOSubmit is not found") 

753 return (<CUfileError_t (*)(CUfileBatchHandle_t, unsigned, CUfileIOParams_t*, unsigned int) noexcept nogil>__cuFileBatchIOSubmit)( 3 ctx1efg

754 batch_idp, nr, iocbp, flags) 

755  

756  

757cdef CUfileError_t _cuFileBatchIOGetStatus(CUfileBatchHandle_t batch_idp, unsigned min_nr, unsigned* nr, CUfileIOEvents_t* iocbp, timespec* timeout) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

758 global __cuFileBatchIOGetStatus 

759 _check_or_init_cufile() 2 ctx1eg

760 if __cuFileBatchIOGetStatus == NULL: 2 ctx1eg

761 with gil: 

762 raise FunctionNotFoundError("function cuFileBatchIOGetStatus is not found") 

763 return (<CUfileError_t (*)(CUfileBatchHandle_t, unsigned, unsigned*, CUfileIOEvents_t*, timespec*) noexcept nogil>__cuFileBatchIOGetStatus)( 2 ctx1eg

764 batch_idp, min_nr, nr, iocbp, timeout) 

765  

766  

767cdef CUfileError_t _cuFileBatchIOCancel(CUfileBatchHandle_t batch_idp) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

768 global __cuFileBatchIOCancel 

769 _check_or_init_cufile() 1 ctx1f

770 if __cuFileBatchIOCancel == NULL: 1 ctx1f

771 with gil: 

772 raise FunctionNotFoundError("function cuFileBatchIOCancel is not found") 

773 return (<CUfileError_t (*)(CUfileBatchHandle_t) noexcept nogil>__cuFileBatchIOCancel)( 1 ctx1f

774 batch_idp) 

775  

776  

777@_cyb_cython.show_performance_hints(False) (empty)

778cdef void _cuFileBatchIODestroy(CUfileBatchHandle_t batch_idp) except* nogil: 

779 global __cuFileBatchIODestroy 

780 _check_or_init_cufile() 3 ctx1efg

781 if __cuFileBatchIODestroy == NULL: 3 ctx1efg

782 with gil: 

783 raise FunctionNotFoundError("function cuFileBatchIODestroy is not found") 

784 (<void (*)(CUfileBatchHandle_t) noexcept nogil>__cuFileBatchIODestroy)( 3 ctx1efg

785 batch_idp) 

786  

787  

788cdef CUfileError_t _cuFileReadAsync(CUfileHandle_t fh, void* bufPtr_base, size_t* size_p, off_t* file_offset_p, off_t* bufPtr_offset_p, ssize_t* bytes_read_p, CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

789 global __cuFileReadAsync 

790 _check_or_init_cufile() 2 ctx1hi

791 if __cuFileReadAsync == NULL: 2 ctx1hi

792 with gil: 

793 raise FunctionNotFoundError("function cuFileReadAsync is not found") 

794 return (<CUfileError_t (*)(CUfileHandle_t, void*, size_t*, off_t*, off_t*, ssize_t*, CUstream) noexcept nogil>__cuFileReadAsync)( 2 ctx1hi

795 fh, bufPtr_base, size_p, file_offset_p, bufPtr_offset_p, bytes_read_p, stream) 

796  

797  

798cdef CUfileError_t _cuFileWriteAsync(CUfileHandle_t fh, void* bufPtr_base, size_t* size_p, off_t* file_offset_p, off_t* bufPtr_offset_p, ssize_t* bytes_written_p, CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

799 global __cuFileWriteAsync 

800 _check_or_init_cufile() 2 ctx1hj

801 if __cuFileWriteAsync == NULL: 2 ctx1hj

802 with gil: 

803 raise FunctionNotFoundError("function cuFileWriteAsync is not found") 

804 return (<CUfileError_t (*)(CUfileHandle_t, void*, size_t*, off_t*, off_t*, ssize_t*, CUstream) noexcept nogil>__cuFileWriteAsync)( 2 ctx1hj

805 fh, bufPtr_base, size_p, file_offset_p, bufPtr_offset_p, bytes_written_p, stream) 

806  

807  

808cdef CUfileError_t _cuFileStreamRegister(CUstream stream, unsigned flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

809 global __cuFileStreamRegister 

810 _check_or_init_cufile() 3 ctx1hij

811 if __cuFileStreamRegister == NULL: 3 ctx1hij

812 with gil: 

813 raise FunctionNotFoundError("function cuFileStreamRegister is not found") 

814 return (<CUfileError_t (*)(CUstream, unsigned) noexcept nogil>__cuFileStreamRegister)( 3 ctx1hij

815 stream, flags) 

816  

817  

818cdef CUfileError_t _cuFileStreamDeregister(CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

819 global __cuFileStreamDeregister 

820 _check_or_init_cufile() 3 ctx1hij

821 if __cuFileStreamDeregister == NULL: 3 ctx1hij

822 with gil: 

823 raise FunctionNotFoundError("function cuFileStreamDeregister is not found") 

824 return (<CUfileError_t (*)(CUstream) noexcept nogil>__cuFileStreamDeregister)( 3 ctx1hij

825 stream) 

826  

827  

828cdef CUfileError_t _cuFileGetVersion(int* version) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

829 global __cuFileGetVersion 

830 _check_or_init_cufile() 2 ctx1an

831 if __cuFileGetVersion == NULL: 2 ctx1an

832 with gil: 

833 raise FunctionNotFoundError("function cuFileGetVersion is not found") 

834 return (<CUfileError_t (*)(int*) noexcept nogil>__cuFileGetVersion)( 2 ctx1an

835 version) 

836  

837  

838cdef CUfileError_t _cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

839 global __cuFileGetParameterSizeT 

840 _check_or_init_cufile() 1 ctx1o

841 if __cuFileGetParameterSizeT == NULL: 1 ctx1o

842 with gil: 

843 raise FunctionNotFoundError("function cuFileGetParameterSizeT is not found") 

844 return (<CUfileError_t (*)(CUFileSizeTConfigParameter_t, size_t*) noexcept nogil>__cuFileGetParameterSizeT)( 1 ctx1o

845 param, value) 

846  

847  

848cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

849 global __cuFileGetParameterBool 

850 _check_or_init_cufile() 1 ctx1n

851 if __cuFileGetParameterBool == NULL: 1 ctx1n

852 with gil: 

853 raise FunctionNotFoundError("function cuFileGetParameterBool is not found") 

854 return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, cpp_bool*) noexcept nogil>__cuFileGetParameterBool)( 1 ctx1n

855 param, value) 

856  

857  

858cdef CUfileError_t _cuFileGetParameterString(CUFileStringConfigParameter_t param, char* desc_str, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

859 global __cuFileGetParameterString 

860 _check_or_init_cufile() 1 ctx1p

861 if __cuFileGetParameterString == NULL: 1 ctx1p

862 with gil: 

863 raise FunctionNotFoundError("function cuFileGetParameterString is not found") 

864 return (<CUfileError_t (*)(CUFileStringConfigParameter_t, char*, int) noexcept nogil>__cuFileGetParameterString)( 1 ctx1p

865 param, desc_str, len) 

866  

867  

868cdef CUfileError_t _cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

869 global __cuFileSetParameterSizeT 

870 _check_or_init_cufile() 1 ctx1o

871 if __cuFileSetParameterSizeT == NULL: 1 ctx1o

872 with gil: 

873 raise FunctionNotFoundError("function cuFileSetParameterSizeT is not found") 

874 return (<CUfileError_t (*)(CUFileSizeTConfigParameter_t, size_t) noexcept nogil>__cuFileSetParameterSizeT)( 1 ctx1o

875 param, value) 

876  

877  

878cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

879 global __cuFileSetParameterBool 

880 _check_or_init_cufile() 1 ctx1n

881 if __cuFileSetParameterBool == NULL: 1 ctx1n

882 with gil: 

883 raise FunctionNotFoundError("function cuFileSetParameterBool is not found") 

884 return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, cpp_bool) noexcept nogil>__cuFileSetParameterBool)( 1 ctx1n

885 param, value) 

886  

887  

888cdef CUfileError_t _cuFileSetParameterString(CUFileStringConfigParameter_t param, const char* desc_str) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

889 global __cuFileSetParameterString 

890 _check_or_init_cufile() 1 ctx1p

891 if __cuFileSetParameterString == NULL: 1 ctx1p

892 with gil: 

893 raise FunctionNotFoundError("function cuFileSetParameterString is not found") 

894 return (<CUfileError_t (*)(CUFileStringConfigParameter_t, const char*) noexcept nogil>__cuFileSetParameterString)( 1 ctx1p

895 param, desc_str) 

896  

897  

898cdef CUfileError_t _cuFileGetParameterMinMaxValue(CUFileSizeTConfigParameter_t param, size_t* min_value, size_t* max_value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

899 global __cuFileGetParameterMinMaxValue 

900 _check_or_init_cufile() 1 ctx1+

901 if __cuFileGetParameterMinMaxValue == NULL: 1 ctx1+

902 with gil: 

903 raise FunctionNotFoundError("function cuFileGetParameterMinMaxValue is not found") 

904 return (<CUfileError_t (*)(CUFileSizeTConfigParameter_t, size_t*, size_t*) noexcept nogil>__cuFileGetParameterMinMaxValue)( 1 ctx1+

905 param, min_value, max_value) 

906  

907  

908cdef CUfileError_t _cuFileSetStatsLevel(int level) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

909 global __cuFileSetStatsLevel 

910 _check_or_init_cufile() 10 ctx1bqcrdsJuvw

911 if __cuFileSetStatsLevel == NULL: 10 ctx1bqcrdsJuvw

912 with gil: 

913 raise FunctionNotFoundError("function cuFileSetStatsLevel is not found") 

914 return (<CUfileError_t (*)(int) noexcept nogil>__cuFileSetStatsLevel)( 10 ctx1bqcrdsJuvw

915 level) 

916  

917  

918cdef CUfileError_t _cuFileGetStatsLevel(int* level) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

919 global __cuFileGetStatsLevel 

920 _check_or_init_cufile() 6 ctx1EFGJKL

921 if __cuFileGetStatsLevel == NULL: 6 ctx1EFGJKL

922 with gil: 

923 raise FunctionNotFoundError("function cuFileGetStatsLevel is not found") 

924 return (<CUfileError_t (*)(int*) noexcept nogil>__cuFileGetStatsLevel)( 6 ctx1EFGJKL

925 level) 

926  

927  

928cdef CUfileError_t _cuFileStatsStart() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

929 global __cuFileStatsStart 

930 _check_or_init_cufile() 4 ctx1bcdv

931 if __cuFileStatsStart == NULL: 4 ctx1bcdv

932 with gil: 

933 raise FunctionNotFoundError("function cuFileStatsStart is not found") 

934 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsStart)( 4 ctx1bcdv

935 ) 

936  

937  

938cdef CUfileError_t _cuFileStatsStop() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

939 global __cuFileStatsStop 

940 _check_or_init_cufile() 4 ctx1bcdv

941 if __cuFileStatsStop == NULL: 4 ctx1bcdv

942 with gil: 

943 raise FunctionNotFoundError("function cuFileStatsStop is not found") 

944 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsStop)( 4 ctx1bcdv

945 ) 

946  

947  

948cdef CUfileError_t _cuFileStatsReset() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

949 global __cuFileStatsReset 

950 _check_or_init_cufile() 5 ctx1qrsuw

951 if __cuFileStatsReset == NULL: 5 ctx1qrsuw

952 with gil: 

953 raise FunctionNotFoundError("function cuFileStatsReset is not found") 

954 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsReset)( 5 ctx1qrsuw

955 ) 

956  

957  

958cdef CUfileError_t _cuFileGetStatsL1(CUfileStatsLevel1_t* stats) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

959 global __cuFileGetStatsL1 

960 _check_or_init_cufile() 1 ctx1b

961 if __cuFileGetStatsL1 == NULL: 1 ctx1b

962 with gil: 

963 raise FunctionNotFoundError("function cuFileGetStatsL1 is not found") 

964 return (<CUfileError_t (*)(CUfileStatsLevel1_t*) noexcept nogil>__cuFileGetStatsL1)( 1 ctx1b

965 stats) 

966  

967  

968cdef CUfileError_t _cuFileGetStatsL2(CUfileStatsLevel2_t* stats) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

969 global __cuFileGetStatsL2 

970 _check_or_init_cufile() 1 ctx1c

971 if __cuFileGetStatsL2 == NULL: 1 ctx1c

972 with gil: 

973 raise FunctionNotFoundError("function cuFileGetStatsL2 is not found") 

974 return (<CUfileError_t (*)(CUfileStatsLevel2_t*) noexcept nogil>__cuFileGetStatsL2)( 1 ctx1c

975 stats) 

976  

977  

978cdef CUfileError_t _cuFileGetStatsL3(CUfileStatsLevel3_t* stats) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

979 global __cuFileGetStatsL3 

980 _check_or_init_cufile() 1 ctx1d

981 if __cuFileGetStatsL3 == NULL: 1 ctx1d

982 with gil: 

983 raise FunctionNotFoundError("function cuFileGetStatsL3 is not found") 

984 return (<CUfileError_t (*)(CUfileStatsLevel3_t*) noexcept nogil>__cuFileGetStatsL3)( 1 ctx1d

985 stats) 

986  

987  

988cdef CUfileError_t _cuFileGetBARSizeInKB(int gpuIndex, size_t* barSize) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

989 global __cuFileGetBARSizeInKB 

990 _check_or_init_cufile() 1 ctx1)

991 if __cuFileGetBARSizeInKB == NULL: 1 ctx1)

992 with gil: 

993 raise FunctionNotFoundError("function cuFileGetBARSizeInKB is not found") 

994 return (<CUfileError_t (*)(int, size_t*) noexcept nogil>__cuFileGetBARSizeInKB)( 1 ctx1)

995 gpuIndex, barSize) 

996  

997  

998cdef CUfileError_t _cuFileSetParameterPosixPoolSlabArray(const size_t* size_values, const size_t* count_values, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

999 global __cuFileSetParameterPosixPoolSlabArray 

1000 _check_or_init_cufile() 1 ctx1I

1001 if __cuFileSetParameterPosixPoolSlabArray == NULL: 1 ctx1I

1002 with gil: 

1003 raise FunctionNotFoundError("function cuFileSetParameterPosixPoolSlabArray is not found") 

1004 return (<CUfileError_t (*)(const size_t*, const size_t*, int) noexcept nogil>__cuFileSetParameterPosixPoolSlabArray)( 1 ctx1I

1005 size_values, count_values, len) 

1006  

1007  

1008cdef CUfileError_t _cuFileGetParameterPosixPoolSlabArray(size_t* size_values, size_t* count_values, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil: (empty)

1009 global __cuFileGetParameterPosixPoolSlabArray 

1010 _check_or_init_cufile() 1 ctx1t

1011 if __cuFileGetParameterPosixPoolSlabArray == NULL: 1 ctx1t

1012 with gil: 

1013 raise FunctionNotFoundError("function cuFileGetParameterPosixPoolSlabArray is not found") 

1014 return (<CUfileError_t (*)(size_t*, size_t*, int) noexcept nogil>__cuFileGetParameterPosixPoolSlabArray)( 1 ctx1t

1015 size_values, count_values, len)