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=5b6e0791dac3bac268169b02ebc748d7375de7189fe7114151716d47791519ad 

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 

49from libcpp cimport bool as _cyb_bool 

50  

51import threading as _cyb_threading (empty)

52  

53cdef int _cyb___py_cufile_init = 0 (empty)

54cdef dict _cyb_func_ptrs = None (empty)

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

56  

57# <<<< END OF PREAMBLE CONTENT >>>> 

58  

59from libc.stdint cimport uintptr_t 

60  

61from .utils import FunctionNotFoundError, NotSupportedError (empty)

62from cuda.pathfinder import load_nvidia_dynamic_lib (empty)

63  

64  

65############################################################################### 

66# Wrapper init 

67############################################################################### 

68  

69  

70cdef void* __cuFileHandleRegister = NULL (empty)

71cdef void* __cuFileHandleDeregister = NULL (empty)

72cdef void* __cuFileBufRegister = NULL (empty)

73cdef void* __cuFileBufDeregister = NULL (empty)

74cdef void* __cuFileRead = NULL (empty)

75cdef void* __cuFileWrite = NULL (empty)

76cdef void* __cuFileDriverOpen = NULL (empty)

77cdef void* __cuFileDriverClose = NULL (empty)

78cdef void* __cuFileDriverClose_v2 = NULL (empty)

79cdef void* __cuFileUseCount = NULL (empty)

80cdef void* __cuFileDriverGetProperties = NULL (empty)

81cdef void* __cuFileDriverSetPollMode = NULL (empty)

82cdef void* __cuFileDriverSetMaxDirectIOSize = NULL (empty)

83cdef void* __cuFileDriverSetMaxCacheSize = NULL (empty)

84cdef void* __cuFileDriverSetMaxPinnedMemSize = NULL (empty)

85cdef void* __cuFileBatchIOSetUp = NULL (empty)

86cdef void* __cuFileBatchIOSubmit = NULL (empty)

87cdef void* __cuFileBatchIOGetStatus = NULL (empty)

88cdef void* __cuFileBatchIOCancel = NULL (empty)

89cdef void* __cuFileBatchIODestroy = NULL (empty)

90cdef void* __cuFileReadAsync = NULL (empty)

91cdef void* __cuFileWriteAsync = NULL (empty)

92cdef void* __cuFileStreamRegister = NULL (empty)

93cdef void* __cuFileStreamDeregister = NULL (empty)

94cdef void* __cuFileGetVersion = NULL (empty)

95cdef void* __cuFileGetParameterSizeT = NULL (empty)

96cdef void* __cuFileGetParameterBool = NULL (empty)

97cdef void* __cuFileGetParameterString = NULL (empty)

98cdef void* __cuFileSetParameterSizeT = NULL (empty)

99cdef void* __cuFileSetParameterBool = NULL (empty)

100cdef void* __cuFileSetParameterString = NULL (empty)

101cdef void* __cuFileGetParameterMinMaxValue = NULL (empty)

102cdef void* __cuFileSetStatsLevel = NULL (empty)

103cdef void* __cuFileGetStatsLevel = NULL (empty)

104cdef void* __cuFileStatsStart = NULL (empty)

105cdef void* __cuFileStatsStop = NULL (empty)

106cdef void* __cuFileStatsReset = NULL (empty)

107cdef void* __cuFileGetStatsL1 = NULL (empty)

108cdef void* __cuFileGetStatsL2 = NULL (empty)

109cdef void* __cuFileGetStatsL3 = NULL (empty)

110cdef void* __cuFileGetBARSizeInKB = NULL (empty)

111cdef void* __cuFileSetParameterPosixPoolSlabArray = NULL (empty)

112cdef void* __cuFileGetParameterPosixPoolSlabArray = NULL (empty)

113  

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

115 global _cyb___py_cufile_init 

116 cdef void* handle = NULL (empty)

117 with gil, _cyb_symbol_lock: (empty)

118 if _cyb___py_cufile_init: return 0 (empty)

119  

120 global __cuFileHandleRegister 

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

122 if __cuFileHandleRegister == NULL: (empty)

123 if handle == NULL: (empty)

124 handle = load_library() (empty)

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

126  

127 global __cuFileHandleDeregister 

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

129 if __cuFileHandleDeregister == NULL: (empty)

130 if handle == NULL: 

131 handle = load_library() 

132 __cuFileHandleDeregister = _cyb_dlsym(handle, 'cuFileHandleDeregister') 

133  

134 global __cuFileBufRegister 

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

136 if __cuFileBufRegister == NULL: (empty)

137 if handle == NULL: 

138 handle = load_library() 

139 __cuFileBufRegister = _cyb_dlsym(handle, 'cuFileBufRegister') 

140  

141 global __cuFileBufDeregister 

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

143 if __cuFileBufDeregister == NULL: (empty)

144 if handle == NULL: 

145 handle = load_library() 

146 __cuFileBufDeregister = _cyb_dlsym(handle, 'cuFileBufDeregister') 

147  

148 global __cuFileRead 

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

150 if __cuFileRead == NULL: (empty)

151 if handle == NULL: 

152 handle = load_library() 

153 __cuFileRead = _cyb_dlsym(handle, 'cuFileRead') 

154  

155 global __cuFileWrite 

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

157 if __cuFileWrite == NULL: (empty)

158 if handle == NULL: 

159 handle = load_library() 

160 __cuFileWrite = _cyb_dlsym(handle, 'cuFileWrite') 

161  

162 global __cuFileDriverOpen 

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

164 if __cuFileDriverOpen == NULL: (empty)

165 if handle == NULL: 

166 handle = load_library() 

167 __cuFileDriverOpen = _cyb_dlsym(handle, 'cuFileDriverOpen') 

168  

169 global __cuFileDriverClose 

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

171 if __cuFileDriverClose == NULL: (empty)

172 if handle == NULL: 

173 handle = load_library() 

174 __cuFileDriverClose = _cyb_dlsym(handle, 'cuFileDriverClose') 

175  

176 global __cuFileDriverClose_v2 

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

178 if __cuFileDriverClose_v2 == NULL: (empty)

179 if handle == NULL: 

180 handle = load_library() 

181 __cuFileDriverClose_v2 = _cyb_dlsym(handle, 'cuFileDriverClose_v2') 

182  

183 global __cuFileUseCount 

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

185 if __cuFileUseCount == NULL: (empty)

186 if handle == NULL: 

187 handle = load_library() 

188 __cuFileUseCount = _cyb_dlsym(handle, 'cuFileUseCount') 

189  

190 global __cuFileDriverGetProperties 

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

192 if __cuFileDriverGetProperties == NULL: (empty)

193 if handle == NULL: 

194 handle = load_library() 

195 __cuFileDriverGetProperties = _cyb_dlsym(handle, 'cuFileDriverGetProperties') 

196  

197 global __cuFileDriverSetPollMode 

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

199 if __cuFileDriverSetPollMode == NULL: (empty)

200 if handle == NULL: 

201 handle = load_library() 

202 __cuFileDriverSetPollMode = _cyb_dlsym(handle, 'cuFileDriverSetPollMode') 

203  

204 global __cuFileDriverSetMaxDirectIOSize 

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

206 if __cuFileDriverSetMaxDirectIOSize == NULL: (empty)

207 if handle == NULL: 

208 handle = load_library() 

209 __cuFileDriverSetMaxDirectIOSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxDirectIOSize') 

210  

211 global __cuFileDriverSetMaxCacheSize 

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

213 if __cuFileDriverSetMaxCacheSize == NULL: (empty)

214 if handle == NULL: 

215 handle = load_library() 

216 __cuFileDriverSetMaxCacheSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxCacheSize') 

217  

218 global __cuFileDriverSetMaxPinnedMemSize 

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

220 if __cuFileDriverSetMaxPinnedMemSize == NULL: (empty)

221 if handle == NULL: 

222 handle = load_library() 

223 __cuFileDriverSetMaxPinnedMemSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxPinnedMemSize') 

224  

225 global __cuFileBatchIOSetUp 

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

227 if __cuFileBatchIOSetUp == NULL: (empty)

228 if handle == NULL: 

229 handle = load_library() 

230 __cuFileBatchIOSetUp = _cyb_dlsym(handle, 'cuFileBatchIOSetUp') 

231  

232 global __cuFileBatchIOSubmit 

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

234 if __cuFileBatchIOSubmit == NULL: (empty)

235 if handle == NULL: 

236 handle = load_library() 

237 __cuFileBatchIOSubmit = _cyb_dlsym(handle, 'cuFileBatchIOSubmit') 

238  

239 global __cuFileBatchIOGetStatus 

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

241 if __cuFileBatchIOGetStatus == NULL: (empty)

242 if handle == NULL: 

243 handle = load_library() 

244 __cuFileBatchIOGetStatus = _cyb_dlsym(handle, 'cuFileBatchIOGetStatus') 

245  

246 global __cuFileBatchIOCancel 

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

248 if __cuFileBatchIOCancel == NULL: (empty)

249 if handle == NULL: 

250 handle = load_library() 

251 __cuFileBatchIOCancel = _cyb_dlsym(handle, 'cuFileBatchIOCancel') 

252  

253 global __cuFileBatchIODestroy 

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

255 if __cuFileBatchIODestroy == NULL: (empty)

256 if handle == NULL: 

257 handle = load_library() 

258 __cuFileBatchIODestroy = _cyb_dlsym(handle, 'cuFileBatchIODestroy') 

259  

260 global __cuFileReadAsync 

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

262 if __cuFileReadAsync == NULL: (empty)

263 if handle == NULL: 

264 handle = load_library() 

265 __cuFileReadAsync = _cyb_dlsym(handle, 'cuFileReadAsync') 

266  

267 global __cuFileWriteAsync 

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

269 if __cuFileWriteAsync == NULL: (empty)

270 if handle == NULL: 

271 handle = load_library() 

272 __cuFileWriteAsync = _cyb_dlsym(handle, 'cuFileWriteAsync') 

273  

274 global __cuFileStreamRegister 

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

276 if __cuFileStreamRegister == NULL: (empty)

277 if handle == NULL: 

278 handle = load_library() 

279 __cuFileStreamRegister = _cyb_dlsym(handle, 'cuFileStreamRegister') 

280  

281 global __cuFileStreamDeregister 

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

283 if __cuFileStreamDeregister == NULL: (empty)

284 if handle == NULL: 

285 handle = load_library() 

286 __cuFileStreamDeregister = _cyb_dlsym(handle, 'cuFileStreamDeregister') 

287  

288 global __cuFileGetVersion 

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

290 if __cuFileGetVersion == NULL: (empty)

291 if handle == NULL: 

292 handle = load_library() 

293 __cuFileGetVersion = _cyb_dlsym(handle, 'cuFileGetVersion') 

294  

295 global __cuFileGetParameterSizeT 

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

297 if __cuFileGetParameterSizeT == NULL: (empty)

298 if handle == NULL: 

299 handle = load_library() 

300 __cuFileGetParameterSizeT = _cyb_dlsym(handle, 'cuFileGetParameterSizeT') 

301  

302 global __cuFileGetParameterBool 

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

304 if __cuFileGetParameterBool == NULL: (empty)

305 if handle == NULL: 

306 handle = load_library() 

307 __cuFileGetParameterBool = _cyb_dlsym(handle, 'cuFileGetParameterBool') 

308  

309 global __cuFileGetParameterString 

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

311 if __cuFileGetParameterString == NULL: (empty)

312 if handle == NULL: 

313 handle = load_library() 

314 __cuFileGetParameterString = _cyb_dlsym(handle, 'cuFileGetParameterString') 

315  

316 global __cuFileSetParameterSizeT 

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

318 if __cuFileSetParameterSizeT == NULL: (empty)

319 if handle == NULL: 

320 handle = load_library() 

321 __cuFileSetParameterSizeT = _cyb_dlsym(handle, 'cuFileSetParameterSizeT') 

322  

323 global __cuFileSetParameterBool 

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

325 if __cuFileSetParameterBool == NULL: (empty)

326 if handle == NULL: 

327 handle = load_library() 

328 __cuFileSetParameterBool = _cyb_dlsym(handle, 'cuFileSetParameterBool') 

329  

330 global __cuFileSetParameterString 

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

332 if __cuFileSetParameterString == NULL: (empty)

333 if handle == NULL: 

334 handle = load_library() 

335 __cuFileSetParameterString = _cyb_dlsym(handle, 'cuFileSetParameterString') 

336  

337 global __cuFileGetParameterMinMaxValue 

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

339 if __cuFileGetParameterMinMaxValue == NULL: (empty)

340 if handle == NULL: 

341 handle = load_library() 

342 __cuFileGetParameterMinMaxValue = _cyb_dlsym(handle, 'cuFileGetParameterMinMaxValue') 

343  

344 global __cuFileSetStatsLevel 

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

346 if __cuFileSetStatsLevel == NULL: (empty)

347 if handle == NULL: 

348 handle = load_library() 

349 __cuFileSetStatsLevel = _cyb_dlsym(handle, 'cuFileSetStatsLevel') 

350  

351 global __cuFileGetStatsLevel 

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

353 if __cuFileGetStatsLevel == NULL: (empty)

354 if handle == NULL: 

355 handle = load_library() 

356 __cuFileGetStatsLevel = _cyb_dlsym(handle, 'cuFileGetStatsLevel') 

357  

358 global __cuFileStatsStart 

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

360 if __cuFileStatsStart == NULL: (empty)

361 if handle == NULL: 

362 handle = load_library() 

363 __cuFileStatsStart = _cyb_dlsym(handle, 'cuFileStatsStart') 

364  

365 global __cuFileStatsStop 

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

367 if __cuFileStatsStop == NULL: (empty)

368 if handle == NULL: 

369 handle = load_library() 

370 __cuFileStatsStop = _cyb_dlsym(handle, 'cuFileStatsStop') 

371  

372 global __cuFileStatsReset 

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

374 if __cuFileStatsReset == NULL: (empty)

375 if handle == NULL: 

376 handle = load_library() 

377 __cuFileStatsReset = _cyb_dlsym(handle, 'cuFileStatsReset') 

378  

379 global __cuFileGetStatsL1 

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

381 if __cuFileGetStatsL1 == NULL: (empty)

382 if handle == NULL: 

383 handle = load_library() 

384 __cuFileGetStatsL1 = _cyb_dlsym(handle, 'cuFileGetStatsL1') 

385  

386 global __cuFileGetStatsL2 

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

388 if __cuFileGetStatsL2 == NULL: (empty)

389 if handle == NULL: 

390 handle = load_library() 

391 __cuFileGetStatsL2 = _cyb_dlsym(handle, 'cuFileGetStatsL2') 

392  

393 global __cuFileGetStatsL3 

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

395 if __cuFileGetStatsL3 == NULL: (empty)

396 if handle == NULL: 

397 handle = load_library() 

398 __cuFileGetStatsL3 = _cyb_dlsym(handle, 'cuFileGetStatsL3') 

399  

400 global __cuFileGetBARSizeInKB 

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

402 if __cuFileGetBARSizeInKB == NULL: (empty)

403 if handle == NULL: 

404 handle = load_library() 

405 __cuFileGetBARSizeInKB = _cyb_dlsym(handle, 'cuFileGetBARSizeInKB') 

406  

407 global __cuFileSetParameterPosixPoolSlabArray 

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

409 if __cuFileSetParameterPosixPoolSlabArray == NULL: (empty)

410 if handle == NULL: 

411 handle = load_library() 

412 __cuFileSetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileSetParameterPosixPoolSlabArray') 

413  

414 global __cuFileGetParameterPosixPoolSlabArray 

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

416 if __cuFileGetParameterPosixPoolSlabArray == NULL: (empty)

417 if handle == NULL: 

418 handle = load_library() 

419 __cuFileGetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileGetParameterPosixPoolSlabArray') 

420  

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

422 return 0 (empty)

423  

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

425 if _cyb_atomic_int_load(<int *>&_cyb___py_cufile_init): 76 ctx1aeLMfNOgPQyRSzTUAVWBXYCZ0D12h34i56k78l9!m#$j%'()*+,-bEqcFrdGsH./noptu:IJvwKx

426 return 0 76 ctx1aeLMfNOgPQyRSzTUAVWBXYCZ0D12h34i56k78l9!m#$j%'()*+,-bEqcFrdGsH./noptu:IJvwKx

427  

428 return _init_cufile() (empty)

429  

430  

431cpdef dict _inspect_function_pointers(): (empty)

432 global _cyb_func_ptrs 

433 if _cyb_func_ptrs is not None: 

434 return _cyb_func_ptrs 

435  

436 _check_or_init_cufile() 

437 cdef dict data = {} 

438 global __cuFileHandleRegister 

439 data["__cuFileHandleRegister"] = <intptr_t>__cuFileHandleRegister 

440  

441 global __cuFileHandleDeregister 

442 data["__cuFileHandleDeregister"] = <intptr_t>__cuFileHandleDeregister 

443  

444 global __cuFileBufRegister 

445 data["__cuFileBufRegister"] = <intptr_t>__cuFileBufRegister 

446  

447 global __cuFileBufDeregister 

448 data["__cuFileBufDeregister"] = <intptr_t>__cuFileBufDeregister 

449  

450 global __cuFileRead 

451 data["__cuFileRead"] = <intptr_t>__cuFileRead 

452  

453 global __cuFileWrite 

454 data["__cuFileWrite"] = <intptr_t>__cuFileWrite 

455  

456 global __cuFileDriverOpen 

457 data["__cuFileDriverOpen"] = <intptr_t>__cuFileDriverOpen 

458  

459 global __cuFileDriverClose 

460 data["__cuFileDriverClose"] = <intptr_t>__cuFileDriverClose 

461  

462 global __cuFileDriverClose_v2 

463 data["__cuFileDriverClose_v2"] = <intptr_t>__cuFileDriverClose_v2 

464  

465 global __cuFileUseCount 

466 data["__cuFileUseCount"] = <intptr_t>__cuFileUseCount 

467  

468 global __cuFileDriverGetProperties 

469 data["__cuFileDriverGetProperties"] = <intptr_t>__cuFileDriverGetProperties 

470  

471 global __cuFileDriverSetPollMode 

472 data["__cuFileDriverSetPollMode"] = <intptr_t>__cuFileDriverSetPollMode 

473  

474 global __cuFileDriverSetMaxDirectIOSize 

475 data["__cuFileDriverSetMaxDirectIOSize"] = <intptr_t>__cuFileDriverSetMaxDirectIOSize 

476  

477 global __cuFileDriverSetMaxCacheSize 

478 data["__cuFileDriverSetMaxCacheSize"] = <intptr_t>__cuFileDriverSetMaxCacheSize 

479  

480 global __cuFileDriverSetMaxPinnedMemSize 

481 data["__cuFileDriverSetMaxPinnedMemSize"] = <intptr_t>__cuFileDriverSetMaxPinnedMemSize 

482  

483 global __cuFileBatchIOSetUp 

484 data["__cuFileBatchIOSetUp"] = <intptr_t>__cuFileBatchIOSetUp 

485  

486 global __cuFileBatchIOSubmit 

487 data["__cuFileBatchIOSubmit"] = <intptr_t>__cuFileBatchIOSubmit 

488  

489 global __cuFileBatchIOGetStatus 

490 data["__cuFileBatchIOGetStatus"] = <intptr_t>__cuFileBatchIOGetStatus 

491  

492 global __cuFileBatchIOCancel 

493 data["__cuFileBatchIOCancel"] = <intptr_t>__cuFileBatchIOCancel 

494  

495 global __cuFileBatchIODestroy 

496 data["__cuFileBatchIODestroy"] = <intptr_t>__cuFileBatchIODestroy 

497  

498 global __cuFileReadAsync 

499 data["__cuFileReadAsync"] = <intptr_t>__cuFileReadAsync 

500  

501 global __cuFileWriteAsync 

502 data["__cuFileWriteAsync"] = <intptr_t>__cuFileWriteAsync 

503  

504 global __cuFileStreamRegister 

505 data["__cuFileStreamRegister"] = <intptr_t>__cuFileStreamRegister 

506  

507 global __cuFileStreamDeregister 

508 data["__cuFileStreamDeregister"] = <intptr_t>__cuFileStreamDeregister 

509  

510 global __cuFileGetVersion 

511 data["__cuFileGetVersion"] = <intptr_t>__cuFileGetVersion 

512  

513 global __cuFileGetParameterSizeT 

514 data["__cuFileGetParameterSizeT"] = <intptr_t>__cuFileGetParameterSizeT 

515  

516 global __cuFileGetParameterBool 

517 data["__cuFileGetParameterBool"] = <intptr_t>__cuFileGetParameterBool 

518  

519 global __cuFileGetParameterString 

520 data["__cuFileGetParameterString"] = <intptr_t>__cuFileGetParameterString 

521  

522 global __cuFileSetParameterSizeT 

523 data["__cuFileSetParameterSizeT"] = <intptr_t>__cuFileSetParameterSizeT 

524  

525 global __cuFileSetParameterBool 

526 data["__cuFileSetParameterBool"] = <intptr_t>__cuFileSetParameterBool 

527  

528 global __cuFileSetParameterString 

529 data["__cuFileSetParameterString"] = <intptr_t>__cuFileSetParameterString 

530  

531 global __cuFileGetParameterMinMaxValue 

532 data["__cuFileGetParameterMinMaxValue"] = <intptr_t>__cuFileGetParameterMinMaxValue 

533  

534 global __cuFileSetStatsLevel 

535 data["__cuFileSetStatsLevel"] = <intptr_t>__cuFileSetStatsLevel 

536  

537 global __cuFileGetStatsLevel 

538 data["__cuFileGetStatsLevel"] = <intptr_t>__cuFileGetStatsLevel 

539  

540 global __cuFileStatsStart 

541 data["__cuFileStatsStart"] = <intptr_t>__cuFileStatsStart 

542  

543 global __cuFileStatsStop 

544 data["__cuFileStatsStop"] = <intptr_t>__cuFileStatsStop 

545  

546 global __cuFileStatsReset 

547 data["__cuFileStatsReset"] = <intptr_t>__cuFileStatsReset 

548  

549 global __cuFileGetStatsL1 

550 data["__cuFileGetStatsL1"] = <intptr_t>__cuFileGetStatsL1 

551  

552 global __cuFileGetStatsL2 

553 data["__cuFileGetStatsL2"] = <intptr_t>__cuFileGetStatsL2 

554  

555 global __cuFileGetStatsL3 

556 data["__cuFileGetStatsL3"] = <intptr_t>__cuFileGetStatsL3 

557  

558 global __cuFileGetBARSizeInKB 

559 data["__cuFileGetBARSizeInKB"] = <intptr_t>__cuFileGetBARSizeInKB 

560  

561 global __cuFileSetParameterPosixPoolSlabArray 

562 data["__cuFileSetParameterPosixPoolSlabArray"] = <intptr_t>__cuFileSetParameterPosixPoolSlabArray 

563  

564 global __cuFileGetParameterPosixPoolSlabArray 

565 data["__cuFileGetParameterPosixPoolSlabArray"] = <intptr_t>__cuFileGetParameterPosixPoolSlabArray 

566 _cyb_func_ptrs = data 

567 return data 

568  

569  

570cpdef _inspect_function_pointer(str name): (empty)

571 global _cyb_func_ptrs 

572 if _cyb_func_ptrs is None: 

573 _cyb_func_ptrs = _inspect_function_pointers() 

574 return _cyb_func_ptrs[name] 

575  

576  

577  

578  

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

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

581 return <void*>handle (empty)

582  

583  

584############################################################################### 

585# Wrapper functions 

586  

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

588 global __cuFileHandleRegister 

589 _check_or_init_cufile() 13 ctx1efghiklmjbcdH

590 if __cuFileHandleRegister == NULL: 13 ctx1efghiklmjbcdH

591 with gil: 

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

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

594 fh, descr) 

595  

596  

597@_cyb_cython.show_performance_hints(False) (empty)

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

599 global __cuFileHandleDeregister 

600 _check_or_init_cufile() 13 ctx1efghiklmjbcdH

601 if __cuFileHandleDeregister == NULL: 13 ctx1efghiklmjbcdH

602 with gil: 

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

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

605 fh) 

606  

607  

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

609 global __cuFileBufRegister 

610 _check_or_init_cufile() 18 ctx1efgyzABCDhiklmjbcd

611 if __cuFileBufRegister == NULL: 18 ctx1efgyzABCDhiklmjbcd

612 with gil: 

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

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

615 bufPtr_base, length, flags) 

616  

617  

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

619 global __cuFileBufDeregister 

620 _check_or_init_cufile() 18 ctx1efgyzABCDhiklmjbcd

621 if __cuFileBufDeregister == NULL: 18 ctx1efgyzABCDhiklmjbcd

622 with gil: 

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

624 return (<CUfileError_t (*)(const void*) noexcept nogil>__cuFileBufDeregister)( 18 ctx1efgyzABCDhiklmjbcd

625 bufPtr_base) 

626  

627  

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

629 global __cuFileRead 

630 _check_or_init_cufile() 6 ctx1klmbcd

631 if __cuFileRead == NULL: 6 ctx1klmbcd

632 with gil: 

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

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

635 fh, bufPtr_base, size, file_offset, bufPtr_offset) 

636  

637  

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

639 global __cuFileWrite 

640 _check_or_init_cufile() 6 ctx1klmbcd

641 if __cuFileWrite == NULL: 6 ctx1klmbcd

642 with gil: 

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

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

645 fh, bufPtr_base, size, file_offset, bufPtr_offset) 

646  

647  

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

649 global __cuFileDriverOpen 

650 _check_or_init_cufile() 28 ctx1LNPRTVXZ13579#%),EFG.noptuJK

651 if __cuFileDriverOpen == NULL: 28 ctx1LNPRTVXZ13579#%),EFG.noptuJK

652 with gil: 

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

654 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverOpen)( 28 ctx1LNPRTVXZ13579#%),EFG.noptuJK

655 ) 

656  

657  

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

659 global __cuFileDriverClose 

660 _check_or_init_cufile() 

661 if __cuFileDriverClose == NULL: 

662 with gil: 

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

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

665 ) 

666  

667  

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

669 global __cuFileDriverClose_v2 

670 _check_or_init_cufile() 29 ctx1MOQSUWY02468!$'*-qrs/noptu:vx

671 if __cuFileDriverClose_v2 == NULL: 29 ctx1MOQSUWY02468!$'*-qrs/noptu:vx

672 with gil: 

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

674 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverClose_v2)( 29 ctx1MOQSUWY02468!$'*-qrs/noptu:vx

675 ) 

676  

677  

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

679 global __cuFileUseCount 

680 _check_or_init_cufile() 

681 if __cuFileUseCount == NULL: 

682 with gil: 

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

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

685 ) 

686  

687  

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

689 global __cuFileDriverGetProperties 

690 _check_or_init_cufile() 

691 if __cuFileDriverGetProperties == NULL: 

692 with gil: 

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

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

695 props) 

696  

697  

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

699 global __cuFileDriverSetPollMode 

700 _check_or_init_cufile() 

701 if __cuFileDriverSetPollMode == NULL: 

702 with gil: 

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

704 return (<CUfileError_t (*)(_cyb_bool, size_t) noexcept nogil>__cuFileDriverSetPollMode)( 

705 poll, poll_threshold_size) 

706  

707  

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

709 global __cuFileDriverSetMaxDirectIOSize 

710 _check_or_init_cufile() 

711 if __cuFileDriverSetMaxDirectIOSize == NULL: 

712 with gil: 

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

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

715 max_direct_io_size) 

716  

717  

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

719 global __cuFileDriverSetMaxCacheSize 

720 _check_or_init_cufile() 

721 if __cuFileDriverSetMaxCacheSize == NULL: 

722 with gil: 

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

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

725 max_cache_size) 

726  

727  

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

729 global __cuFileDriverSetMaxPinnedMemSize 

730 _check_or_init_cufile() 

731 if __cuFileDriverSetMaxPinnedMemSize == NULL: 

732 with gil: 

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

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

735 max_pinned_size) 

736  

737  

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

739 global __cuFileBatchIOSetUp 

740 _check_or_init_cufile() 3 ctx1efg

741 if __cuFileBatchIOSetUp == NULL: 3 ctx1efg

742 with gil: 

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

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

745 batch_idp, nr) 

746  

747  

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

749 global __cuFileBatchIOSubmit 

750 _check_or_init_cufile() 3 ctx1efg

751 if __cuFileBatchIOSubmit == NULL: 3 ctx1efg

752 with gil: 

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

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

755 batch_idp, nr, iocbp, flags) 

756  

757  

758cdef 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)

759 global __cuFileBatchIOGetStatus 

760 _check_or_init_cufile() 2 ctx1eg

761 if __cuFileBatchIOGetStatus == NULL: 2 ctx1eg

762 with gil: 

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

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

765 batch_idp, min_nr, nr, iocbp, timeout) 

766  

767  

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

769 global __cuFileBatchIOCancel 

770 _check_or_init_cufile() 1 ctx1f

771 if __cuFileBatchIOCancel == NULL: 1 ctx1f

772 with gil: 

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

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

775 batch_idp) 

776  

777  

778@_cyb_cython.show_performance_hints(False) (empty)

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

780 global __cuFileBatchIODestroy 

781 _check_or_init_cufile() 3 ctx1efg

782 if __cuFileBatchIODestroy == NULL: 3 ctx1efg

783 with gil: 

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

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

786 batch_idp) 

787  

788  

789cdef 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)

790 global __cuFileReadAsync 

791 _check_or_init_cufile() 2 ctx1hi

792 if __cuFileReadAsync == NULL: 2 ctx1hi

793 with gil: 

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

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

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

797  

798  

799cdef 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)

800 global __cuFileWriteAsync 

801 _check_or_init_cufile() 2 ctx1hj

802 if __cuFileWriteAsync == NULL: 2 ctx1hj

803 with gil: 

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

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

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

807  

808  

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

810 global __cuFileStreamRegister 

811 _check_or_init_cufile() 3 ctx1hij

812 if __cuFileStreamRegister == NULL: 3 ctx1hij

813 with gil: 

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

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

816 stream, flags) 

817  

818  

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

820 global __cuFileStreamDeregister 

821 _check_or_init_cufile() 3 ctx1hij

822 if __cuFileStreamDeregister == NULL: 3 ctx1hij

823 with gil: 

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

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

826 stream) 

827  

828  

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

830 global __cuFileGetVersion 

831 _check_or_init_cufile() 2 ctx1an

832 if __cuFileGetVersion == NULL: 2 ctx1an

833 with gil: 

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

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

836 version) 

837  

838  

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

840 global __cuFileGetParameterSizeT 

841 _check_or_init_cufile() 1 ctx1o

842 if __cuFileGetParameterSizeT == NULL: 1 ctx1o

843 with gil: 

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

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

846 param, value) 

847  

848  

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

850 global __cuFileGetParameterBool 

851 _check_or_init_cufile() 1 ctx1n

852 if __cuFileGetParameterBool == NULL: 1 ctx1n

853 with gil: 

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

855 return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, _cyb_bool*) noexcept nogil>__cuFileGetParameterBool)( 1 ctx1n

856 param, value) 

857  

858  

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

860 global __cuFileGetParameterString 

861 _check_or_init_cufile() 1 ctx1p

862 if __cuFileGetParameterString == NULL: 1 ctx1p

863 with gil: 

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

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

866 param, desc_str, len) 

867  

868  

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

870 global __cuFileSetParameterSizeT 

871 _check_or_init_cufile() 1 ctx1o

872 if __cuFileSetParameterSizeT == NULL: 1 ctx1o

873 with gil: 

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

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

876 param, value) 

877  

878  

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

880 global __cuFileSetParameterBool 

881 _check_or_init_cufile() 1 ctx1n

882 if __cuFileSetParameterBool == NULL: 1 ctx1n

883 with gil: 

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

885 return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, _cyb_bool) noexcept nogil>__cuFileSetParameterBool)( 1 ctx1n

886 param, value) 

887  

888  

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

890 global __cuFileSetParameterString 

891 _check_or_init_cufile() 1 ctx1p

892 if __cuFileSetParameterString == NULL: 1 ctx1p

893 with gil: 

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

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

896 param, desc_str) 

897  

898  

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

900 global __cuFileGetParameterMinMaxValue 

901 _check_or_init_cufile() 1 ctx1+

902 if __cuFileGetParameterMinMaxValue == NULL: 1 ctx1+

903 with gil: 

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

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

906 param, min_value, max_value) 

907  

908  

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

910 global __cuFileSetStatsLevel 

911 _check_or_init_cufile() 10 ctx1bqcrdsIvwx

912 if __cuFileSetStatsLevel == NULL: 10 ctx1bqcrdsIvwx

913 with gil: 

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

915 return (<CUfileError_t (*)(int) noexcept nogil>__cuFileSetStatsLevel)( 10 ctx1bqcrdsIvwx

916 level) 

917  

918  

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

920 global __cuFileGetStatsLevel 

921 _check_or_init_cufile() 6 ctx1EFGIJK

922 if __cuFileGetStatsLevel == NULL: 6 ctx1EFGIJK

923 with gil: 

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

925 return (<CUfileError_t (*)(int*) noexcept nogil>__cuFileGetStatsLevel)( 6 ctx1EFGIJK

926 level) 

927  

928  

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

930 global __cuFileStatsStart 

931 _check_or_init_cufile() 4 ctx1bcdw

932 if __cuFileStatsStart == NULL: 4 ctx1bcdw

933 with gil: 

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

935 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsStart)( 4 ctx1bcdw

936 ) 

937  

938  

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

940 global __cuFileStatsStop 

941 _check_or_init_cufile() 4 ctx1bcdw

942 if __cuFileStatsStop == NULL: 4 ctx1bcdw

943 with gil: 

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

945 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsStop)( 4 ctx1bcdw

946 ) 

947  

948  

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

950 global __cuFileStatsReset 

951 _check_or_init_cufile() 5 ctx1qrsvx

952 if __cuFileStatsReset == NULL: 5 ctx1qrsvx

953 with gil: 

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

955 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsReset)( 5 ctx1qrsvx

956 ) 

957  

958  

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

960 global __cuFileGetStatsL1 

961 _check_or_init_cufile() 1 ctx1b

962 if __cuFileGetStatsL1 == NULL: 1 ctx1b

963 with gil: 

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

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

966 stats) 

967  

968  

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

970 global __cuFileGetStatsL2 

971 _check_or_init_cufile() 1 ctx1c

972 if __cuFileGetStatsL2 == NULL: 1 ctx1c

973 with gil: 

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

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

976 stats) 

977  

978  

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

980 global __cuFileGetStatsL3 

981 _check_or_init_cufile() 1 ctx1d

982 if __cuFileGetStatsL3 == NULL: 1 ctx1d

983 with gil: 

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

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

986 stats) 

987  

988  

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

990 global __cuFileGetBARSizeInKB 

991 _check_or_init_cufile() 1 ctx1(

992 if __cuFileGetBARSizeInKB == NULL: 1 ctx1(

993 with gil: 

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

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

996 gpuIndex, barSize) 

997  

998  

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

1000 global __cuFileSetParameterPosixPoolSlabArray 

1001 _check_or_init_cufile() 1 ctx1u

1002 if __cuFileSetParameterPosixPoolSlabArray == NULL: 1 ctx1u

1003 with gil: 

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

1005 return (<CUfileError_t (*)(const size_t*, const size_t*, int) noexcept nogil>__cuFileSetParameterPosixPoolSlabArray)( 1 ctx1u

1006 size_values, count_values, len) 

1007  

1008  

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

1010 global __cuFileGetParameterPosixPoolSlabArray 

1011 _check_or_init_cufile() 1 ctx1t

1012 if __cuFileGetParameterPosixPoolSlabArray == NULL: 1 ctx1t

1013 with gil: 

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

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

1016 size_values, count_values, len)