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=ae15aefcbc4ccf2d415fb5d6436ae854690559f5561704523ba7d6f45abfc592 

7  

8  

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

10  

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

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

13 const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" 

14  

15cimport cython as _cyb_cython 

16from libc.stdint cimport intptr_t as _cyb_intptr_t 

17  

18import threading as _cyb_threading (empty)

19  

20cdef bint _cyb___py_cufile_init = False (empty)

21cdef dict _cyb_func_ptrs = None (empty)

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

23  

24# <<<< END OF PREAMBLE CONTENT >>>> 

25  

26from libc.stdint cimport uintptr_t 

27  

28from .utils import FunctionNotFoundError, NotSupportedError (empty)

29from cuda.pathfinder import load_nvidia_dynamic_lib (empty)

30  

31  

32############################################################################### 

33# Wrapper init 

34############################################################################### 

35  

36  

37cdef void* __cuFileHandleRegister = NULL (empty)

38cdef void* __cuFileHandleDeregister = NULL (empty)

39cdef void* __cuFileBufRegister = NULL (empty)

40cdef void* __cuFileBufDeregister = NULL (empty)

41cdef void* __cuFileRead = NULL (empty)

42cdef void* __cuFileWrite = NULL (empty)

43cdef void* __cuFileDriverOpen = NULL (empty)

44cdef void* __cuFileDriverClose = NULL (empty)

45cdef void* __cuFileDriverClose_v2 = NULL (empty)

46cdef void* __cuFileUseCount = NULL (empty)

47cdef void* __cuFileDriverGetProperties = NULL (empty)

48cdef void* __cuFileDriverSetPollMode = NULL (empty)

49cdef void* __cuFileDriverSetMaxDirectIOSize = NULL (empty)

50cdef void* __cuFileDriverSetMaxCacheSize = NULL (empty)

51cdef void* __cuFileDriverSetMaxPinnedMemSize = NULL (empty)

52cdef void* __cuFileBatchIOSetUp = NULL (empty)

53cdef void* __cuFileBatchIOSubmit = NULL (empty)

54cdef void* __cuFileBatchIOGetStatus = NULL (empty)

55cdef void* __cuFileBatchIOCancel = NULL (empty)

56cdef void* __cuFileBatchIODestroy = NULL (empty)

57cdef void* __cuFileReadAsync = NULL (empty)

58cdef void* __cuFileWriteAsync = NULL (empty)

59cdef void* __cuFileStreamRegister = NULL (empty)

60cdef void* __cuFileStreamDeregister = NULL (empty)

61cdef void* __cuFileGetVersion = NULL (empty)

62cdef void* __cuFileGetParameterSizeT = NULL (empty)

63cdef void* __cuFileGetParameterBool = NULL (empty)

64cdef void* __cuFileGetParameterString = NULL (empty)

65cdef void* __cuFileSetParameterSizeT = NULL (empty)

66cdef void* __cuFileSetParameterBool = NULL (empty)

67cdef void* __cuFileSetParameterString = NULL (empty)

68cdef void* __cuFileGetParameterMinMaxValue = NULL (empty)

69cdef void* __cuFileSetStatsLevel = NULL (empty)

70cdef void* __cuFileGetStatsLevel = NULL (empty)

71cdef void* __cuFileStatsStart = NULL (empty)

72cdef void* __cuFileStatsStop = NULL (empty)

73cdef void* __cuFileStatsReset = NULL (empty)

74cdef void* __cuFileGetStatsL1 = NULL (empty)

75cdef void* __cuFileGetStatsL2 = NULL (empty)

76cdef void* __cuFileGetStatsL3 = NULL (empty)

77cdef void* __cuFileGetBARSizeInKB = NULL (empty)

78cdef void* __cuFileSetParameterPosixPoolSlabArray = NULL (empty)

79cdef void* __cuFileGetParameterPosixPoolSlabArray = NULL (empty)

80  

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

82 global _cyb___py_cufile_init 

83 cdef void* handle = NULL (empty)

84 with gil, _cyb_symbol_lock: (empty)

85 if _cyb___py_cufile_init: return 0 (empty)

86  

87 global __cuFileHandleRegister 

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

89 if __cuFileHandleRegister == NULL: (empty)

90 if handle == NULL: (empty)

91 handle = load_library() (empty)

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

93  

94 global __cuFileHandleDeregister 

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

96 if __cuFileHandleDeregister == NULL: (empty)

97 if handle == NULL: 

98 handle = load_library() 

99 __cuFileHandleDeregister = _cyb_dlsym(handle, 'cuFileHandleDeregister') 

100  

101 global __cuFileBufRegister 

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

103 if __cuFileBufRegister == NULL: (empty)

104 if handle == NULL: 

105 handle = load_library() 

106 __cuFileBufRegister = _cyb_dlsym(handle, 'cuFileBufRegister') 

107  

108 global __cuFileBufDeregister 

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

110 if __cuFileBufDeregister == NULL: (empty)

111 if handle == NULL: 

112 handle = load_library() 

113 __cuFileBufDeregister = _cyb_dlsym(handle, 'cuFileBufDeregister') 

114  

115 global __cuFileRead 

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

117 if __cuFileRead == NULL: (empty)

118 if handle == NULL: 

119 handle = load_library() 

120 __cuFileRead = _cyb_dlsym(handle, 'cuFileRead') 

121  

122 global __cuFileWrite 

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

124 if __cuFileWrite == NULL: (empty)

125 if handle == NULL: 

126 handle = load_library() 

127 __cuFileWrite = _cyb_dlsym(handle, 'cuFileWrite') 

128  

129 global __cuFileDriverOpen 

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

131 if __cuFileDriverOpen == NULL: (empty)

132 if handle == NULL: 

133 handle = load_library() 

134 __cuFileDriverOpen = _cyb_dlsym(handle, 'cuFileDriverOpen') 

135  

136 global __cuFileDriverClose 

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

138 if __cuFileDriverClose == NULL: (empty)

139 if handle == NULL: 

140 handle = load_library() 

141 __cuFileDriverClose = _cyb_dlsym(handle, 'cuFileDriverClose') 

142  

143 global __cuFileDriverClose_v2 

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

145 if __cuFileDriverClose_v2 == NULL: (empty)

146 if handle == NULL: 

147 handle = load_library() 

148 __cuFileDriverClose_v2 = _cyb_dlsym(handle, 'cuFileDriverClose_v2') 

149  

150 global __cuFileUseCount 

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

152 if __cuFileUseCount == NULL: (empty)

153 if handle == NULL: 

154 handle = load_library() 

155 __cuFileUseCount = _cyb_dlsym(handle, 'cuFileUseCount') 

156  

157 global __cuFileDriverGetProperties 

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

159 if __cuFileDriverGetProperties == NULL: (empty)

160 if handle == NULL: 

161 handle = load_library() 

162 __cuFileDriverGetProperties = _cyb_dlsym(handle, 'cuFileDriverGetProperties') 

163  

164 global __cuFileDriverSetPollMode 

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

166 if __cuFileDriverSetPollMode == NULL: (empty)

167 if handle == NULL: 

168 handle = load_library() 

169 __cuFileDriverSetPollMode = _cyb_dlsym(handle, 'cuFileDriverSetPollMode') 

170  

171 global __cuFileDriverSetMaxDirectIOSize 

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

173 if __cuFileDriverSetMaxDirectIOSize == NULL: (empty)

174 if handle == NULL: 

175 handle = load_library() 

176 __cuFileDriverSetMaxDirectIOSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxDirectIOSize') 

177  

178 global __cuFileDriverSetMaxCacheSize 

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

180 if __cuFileDriverSetMaxCacheSize == NULL: (empty)

181 if handle == NULL: 

182 handle = load_library() 

183 __cuFileDriverSetMaxCacheSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxCacheSize') 

184  

185 global __cuFileDriverSetMaxPinnedMemSize 

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

187 if __cuFileDriverSetMaxPinnedMemSize == NULL: (empty)

188 if handle == NULL: 

189 handle = load_library() 

190 __cuFileDriverSetMaxPinnedMemSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxPinnedMemSize') 

191  

192 global __cuFileBatchIOSetUp 

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

194 if __cuFileBatchIOSetUp == NULL: (empty)

195 if handle == NULL: 

196 handle = load_library() 

197 __cuFileBatchIOSetUp = _cyb_dlsym(handle, 'cuFileBatchIOSetUp') 

198  

199 global __cuFileBatchIOSubmit 

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

201 if __cuFileBatchIOSubmit == NULL: (empty)

202 if handle == NULL: 

203 handle = load_library() 

204 __cuFileBatchIOSubmit = _cyb_dlsym(handle, 'cuFileBatchIOSubmit') 

205  

206 global __cuFileBatchIOGetStatus 

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

208 if __cuFileBatchIOGetStatus == NULL: (empty)

209 if handle == NULL: 

210 handle = load_library() 

211 __cuFileBatchIOGetStatus = _cyb_dlsym(handle, 'cuFileBatchIOGetStatus') 

212  

213 global __cuFileBatchIOCancel 

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

215 if __cuFileBatchIOCancel == NULL: (empty)

216 if handle == NULL: 

217 handle = load_library() 

218 __cuFileBatchIOCancel = _cyb_dlsym(handle, 'cuFileBatchIOCancel') 

219  

220 global __cuFileBatchIODestroy 

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

222 if __cuFileBatchIODestroy == NULL: (empty)

223 if handle == NULL: 

224 handle = load_library() 

225 __cuFileBatchIODestroy = _cyb_dlsym(handle, 'cuFileBatchIODestroy') 

226  

227 global __cuFileReadAsync 

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

229 if __cuFileReadAsync == NULL: (empty)

230 if handle == NULL: 

231 handle = load_library() 

232 __cuFileReadAsync = _cyb_dlsym(handle, 'cuFileReadAsync') 

233  

234 global __cuFileWriteAsync 

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

236 if __cuFileWriteAsync == NULL: (empty)

237 if handle == NULL: 

238 handle = load_library() 

239 __cuFileWriteAsync = _cyb_dlsym(handle, 'cuFileWriteAsync') 

240  

241 global __cuFileStreamRegister 

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

243 if __cuFileStreamRegister == NULL: (empty)

244 if handle == NULL: 

245 handle = load_library() 

246 __cuFileStreamRegister = _cyb_dlsym(handle, 'cuFileStreamRegister') 

247  

248 global __cuFileStreamDeregister 

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

250 if __cuFileStreamDeregister == NULL: (empty)

251 if handle == NULL: 

252 handle = load_library() 

253 __cuFileStreamDeregister = _cyb_dlsym(handle, 'cuFileStreamDeregister') 

254  

255 global __cuFileGetVersion 

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

257 if __cuFileGetVersion == NULL: (empty)

258 if handle == NULL: 

259 handle = load_library() 

260 __cuFileGetVersion = _cyb_dlsym(handle, 'cuFileGetVersion') 

261  

262 global __cuFileGetParameterSizeT 

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

264 if __cuFileGetParameterSizeT == NULL: (empty)

265 if handle == NULL: 

266 handle = load_library() 

267 __cuFileGetParameterSizeT = _cyb_dlsym(handle, 'cuFileGetParameterSizeT') 

268  

269 global __cuFileGetParameterBool 

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

271 if __cuFileGetParameterBool == NULL: (empty)

272 if handle == NULL: 

273 handle = load_library() 

274 __cuFileGetParameterBool = _cyb_dlsym(handle, 'cuFileGetParameterBool') 

275  

276 global __cuFileGetParameterString 

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

278 if __cuFileGetParameterString == NULL: (empty)

279 if handle == NULL: 

280 handle = load_library() 

281 __cuFileGetParameterString = _cyb_dlsym(handle, 'cuFileGetParameterString') 

282  

283 global __cuFileSetParameterSizeT 

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

285 if __cuFileSetParameterSizeT == NULL: (empty)

286 if handle == NULL: 

287 handle = load_library() 

288 __cuFileSetParameterSizeT = _cyb_dlsym(handle, 'cuFileSetParameterSizeT') 

289  

290 global __cuFileSetParameterBool 

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

292 if __cuFileSetParameterBool == NULL: (empty)

293 if handle == NULL: 

294 handle = load_library() 

295 __cuFileSetParameterBool = _cyb_dlsym(handle, 'cuFileSetParameterBool') 

296  

297 global __cuFileSetParameterString 

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

299 if __cuFileSetParameterString == NULL: (empty)

300 if handle == NULL: 

301 handle = load_library() 

302 __cuFileSetParameterString = _cyb_dlsym(handle, 'cuFileSetParameterString') 

303  

304 global __cuFileGetParameterMinMaxValue 

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

306 if __cuFileGetParameterMinMaxValue == NULL: (empty)

307 if handle == NULL: 

308 handle = load_library() 

309 __cuFileGetParameterMinMaxValue = _cyb_dlsym(handle, 'cuFileGetParameterMinMaxValue') 

310  

311 global __cuFileSetStatsLevel 

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

313 if __cuFileSetStatsLevel == NULL: (empty)

314 if handle == NULL: 

315 handle = load_library() 

316 __cuFileSetStatsLevel = _cyb_dlsym(handle, 'cuFileSetStatsLevel') 

317  

318 global __cuFileGetStatsLevel 

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

320 if __cuFileGetStatsLevel == NULL: (empty)

321 if handle == NULL: 

322 handle = load_library() 

323 __cuFileGetStatsLevel = _cyb_dlsym(handle, 'cuFileGetStatsLevel') 

324  

325 global __cuFileStatsStart 

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

327 if __cuFileStatsStart == NULL: (empty)

328 if handle == NULL: 

329 handle = load_library() 

330 __cuFileStatsStart = _cyb_dlsym(handle, 'cuFileStatsStart') 

331  

332 global __cuFileStatsStop 

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

334 if __cuFileStatsStop == NULL: (empty)

335 if handle == NULL: 

336 handle = load_library() 

337 __cuFileStatsStop = _cyb_dlsym(handle, 'cuFileStatsStop') 

338  

339 global __cuFileStatsReset 

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

341 if __cuFileStatsReset == NULL: (empty)

342 if handle == NULL: 

343 handle = load_library() 

344 __cuFileStatsReset = _cyb_dlsym(handle, 'cuFileStatsReset') 

345  

346 global __cuFileGetStatsL1 

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

348 if __cuFileGetStatsL1 == NULL: (empty)

349 if handle == NULL: 

350 handle = load_library() 

351 __cuFileGetStatsL1 = _cyb_dlsym(handle, 'cuFileGetStatsL1') 

352  

353 global __cuFileGetStatsL2 

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

355 if __cuFileGetStatsL2 == NULL: (empty)

356 if handle == NULL: 

357 handle = load_library() 

358 __cuFileGetStatsL2 = _cyb_dlsym(handle, 'cuFileGetStatsL2') 

359  

360 global __cuFileGetStatsL3 

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

362 if __cuFileGetStatsL3 == NULL: (empty)

363 if handle == NULL: 

364 handle = load_library() 

365 __cuFileGetStatsL3 = _cyb_dlsym(handle, 'cuFileGetStatsL3') 

366  

367 global __cuFileGetBARSizeInKB 

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

369 if __cuFileGetBARSizeInKB == NULL: (empty)

370 if handle == NULL: 

371 handle = load_library() 

372 __cuFileGetBARSizeInKB = _cyb_dlsym(handle, 'cuFileGetBARSizeInKB') 

373  

374 global __cuFileSetParameterPosixPoolSlabArray 

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

376 if __cuFileSetParameterPosixPoolSlabArray == NULL: (empty)

377 if handle == NULL: 

378 handle = load_library() 

379 __cuFileSetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileSetParameterPosixPoolSlabArray') 

380  

381 global __cuFileGetParameterPosixPoolSlabArray 

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

383 if __cuFileGetParameterPosixPoolSlabArray == NULL: (empty)

384 if handle == NULL: 

385 handle = load_library() 

386 __cuFileGetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileGetParameterPosixPoolSlabArray') 

387  

388 _cyb___py_cufile_init = True (empty)

389 return 0 (empty)

390  

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

392 if _cyb___py_cufile_init: 77 ctx1aeMNfOPgQRxSTyUVzWXAYZB01C23h45i67k89l!#m$%j'()*+,-.bDqcErdFsG/:nHoptI;JKuvLw

393 return 0 77 ctx1aeMNfOPgQRxSTyUVzWXAYZB01C23h45i67k89l!#m$%j'()*+,-.bDqcErdFsG/:nHoptI;JKuvLw

394  

395 return _init_cufile() (empty)

396  

397  

398cpdef dict _inspect_function_pointers(): (empty)

399 global _cyb_func_ptrs 

400 if _cyb_func_ptrs is not None: 

401 return _cyb_func_ptrs 

402  

403 _check_or_init_cufile() 

404 cdef dict data = {} 

405 global __cuFileHandleRegister 

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

407  

408 global __cuFileHandleDeregister 

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

410  

411 global __cuFileBufRegister 

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

413  

414 global __cuFileBufDeregister 

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

416  

417 global __cuFileRead 

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

419  

420 global __cuFileWrite 

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

422  

423 global __cuFileDriverOpen 

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

425  

426 global __cuFileDriverClose 

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

428  

429 global __cuFileDriverClose_v2 

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

431  

432 global __cuFileUseCount 

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

434  

435 global __cuFileDriverGetProperties 

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

437  

438 global __cuFileDriverSetPollMode 

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

440  

441 global __cuFileDriverSetMaxDirectIOSize 

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

443  

444 global __cuFileDriverSetMaxCacheSize 

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

446  

447 global __cuFileDriverSetMaxPinnedMemSize 

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

449  

450 global __cuFileBatchIOSetUp 

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

452  

453 global __cuFileBatchIOSubmit 

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

455  

456 global __cuFileBatchIOGetStatus 

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

458  

459 global __cuFileBatchIOCancel 

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

461  

462 global __cuFileBatchIODestroy 

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

464  

465 global __cuFileReadAsync 

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

467  

468 global __cuFileWriteAsync 

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

470  

471 global __cuFileStreamRegister 

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

473  

474 global __cuFileStreamDeregister 

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

476  

477 global __cuFileGetVersion 

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

479  

480 global __cuFileGetParameterSizeT 

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

482  

483 global __cuFileGetParameterBool 

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

485  

486 global __cuFileGetParameterString 

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

488  

489 global __cuFileSetParameterSizeT 

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

491  

492 global __cuFileSetParameterBool 

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

494  

495 global __cuFileSetParameterString 

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

497  

498 global __cuFileGetParameterMinMaxValue 

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

500  

501 global __cuFileSetStatsLevel 

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

503  

504 global __cuFileGetStatsLevel 

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

506  

507 global __cuFileStatsStart 

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

509  

510 global __cuFileStatsStop 

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

512  

513 global __cuFileStatsReset 

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

515  

516 global __cuFileGetStatsL1 

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

518  

519 global __cuFileGetStatsL2 

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

521  

522 global __cuFileGetStatsL3 

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

524  

525 global __cuFileGetBARSizeInKB 

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

527  

528 global __cuFileSetParameterPosixPoolSlabArray 

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

530  

531 global __cuFileGetParameterPosixPoolSlabArray 

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

533 _cyb_func_ptrs = data 

534 return data 

535  

536  

537cpdef _inspect_function_pointer(str name): (empty)

538 global _cyb_func_ptrs 

539 if _cyb_func_ptrs is None: 

540 _cyb_func_ptrs = _inspect_function_pointers() 

541 return _cyb_func_ptrs[name] 

542  

543  

544  

545  

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

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

548 return <void*>handle (empty)

549  

550  

551############################################################################### 

552# Wrapper functions 

553  

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

555 global __cuFileHandleRegister 

556 _check_or_init_cufile() 13 ctx1efghiklmjbcdG

557 if __cuFileHandleRegister == NULL: 13 ctx1efghiklmjbcdG

558 with gil: 

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

560 return (<CUfileError_t (*)(CUfileHandle_t*, CUfileDescr_t*) noexcept nogil>__cuFileHandleRegister)( 13 ctx1efghiklmjbcdG

561 fh, descr) 

562  

563  

564@_cyb_cython.show_performance_hints(False) (empty)

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

566 global __cuFileHandleDeregister 

567 _check_or_init_cufile() 13 ctx1efghiklmjbcdG

568 if __cuFileHandleDeregister == NULL: 13 ctx1efghiklmjbcdG

569 with gil: 

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

571 (<void (*)(CUfileHandle_t) noexcept nogil>__cuFileHandleDeregister)( 13 ctx1efghiklmjbcdG

572 fh) 

573  

574  

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

576 global __cuFileBufRegister 

577 _check_or_init_cufile() 18 ctx1efgxyzABChiklmjbcd

578 if __cuFileBufRegister == NULL: 18 ctx1efgxyzABChiklmjbcd

579 with gil: 

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

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

582 bufPtr_base, length, flags) 

583  

584  

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

586 global __cuFileBufDeregister 

587 _check_or_init_cufile() 18 ctx1efgxyzABChiklmjbcd

588 if __cuFileBufDeregister == NULL: 18 ctx1efgxyzABChiklmjbcd

589 with gil: 

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

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

592 bufPtr_base) 

593  

594  

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

596 global __cuFileRead 

597 _check_or_init_cufile() 6 ctx1klmbcd

598 if __cuFileRead == NULL: 6 ctx1klmbcd

599 with gil: 

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

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

602 fh, bufPtr_base, size, file_offset, bufPtr_offset) 

603  

604  

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

606 global __cuFileWrite 

607 _check_or_init_cufile() 6 ctx1klmbcd

608 if __cuFileWrite == NULL: 6 ctx1klmbcd

609 with gil: 

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

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

612 fh, bufPtr_base, size, file_offset, bufPtr_offset) 

613  

614  

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

616 global __cuFileDriverOpen 

617 _check_or_init_cufile() 29 ctx1MOQSUWY02468!$'*-DEF/nHoptIKL

618 if __cuFileDriverOpen == NULL: 29 ctx1MOQSUWY02468!$'*-DEF/nHoptIKL

619 with gil: 

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

621 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverOpen)( 29 ctx1MOQSUWY02468!$'*-DEF/nHoptIKL

622 ) 

623  

624  

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

626 global __cuFileDriverClose 

627 _check_or_init_cufile() 

628 if __cuFileDriverClose == NULL: 

629 with gil: 

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

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

632 ) 

633  

634  

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

636 global __cuFileDriverClose_v2 

637 _check_or_init_cufile() 29 ctx1NPRTVXZ13579#%(+.qrs:nHopt;uw

638 if __cuFileDriverClose_v2 == NULL: 29 ctx1NPRTVXZ13579#%(+.qrs:nHopt;uw

639 with gil: 

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

641 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverClose_v2)( 29 ctx1NPRTVXZ13579#%(+.qrs:nHopt;uw

642 ) 

643  

644  

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

646 global __cuFileUseCount 

647 _check_or_init_cufile() 

648 if __cuFileUseCount == NULL: 

649 with gil: 

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

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

652 ) 

653  

654  

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

656 global __cuFileDriverGetProperties 

657 _check_or_init_cufile() 

658 if __cuFileDriverGetProperties == NULL: 

659 with gil: 

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

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

662 props) 

663  

664  

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

666 global __cuFileDriverSetPollMode 

667 _check_or_init_cufile() 

668 if __cuFileDriverSetPollMode == NULL: 

669 with gil: 

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

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

672 poll, poll_threshold_size) 

673  

674  

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

676 global __cuFileDriverSetMaxDirectIOSize 

677 _check_or_init_cufile() 

678 if __cuFileDriverSetMaxDirectIOSize == NULL: 

679 with gil: 

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

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

682 max_direct_io_size) 

683  

684  

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

686 global __cuFileDriverSetMaxCacheSize 

687 _check_or_init_cufile() 

688 if __cuFileDriverSetMaxCacheSize == NULL: 

689 with gil: 

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

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

692 max_cache_size) 

693  

694  

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

696 global __cuFileDriverSetMaxPinnedMemSize 

697 _check_or_init_cufile() 

698 if __cuFileDriverSetMaxPinnedMemSize == NULL: 

699 with gil: 

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

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

702 max_pinned_size) 

703  

704  

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

706 global __cuFileBatchIOSetUp 

707 _check_or_init_cufile() 3 ctx1efg

708 if __cuFileBatchIOSetUp == NULL: 3 ctx1efg

709 with gil: 

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

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

712 batch_idp, nr) 

713  

714  

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

716 global __cuFileBatchIOSubmit 

717 _check_or_init_cufile() 3 ctx1efg

718 if __cuFileBatchIOSubmit == NULL: 3 ctx1efg

719 with gil: 

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

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

722 batch_idp, nr, iocbp, flags) 

723  

724  

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

726 global __cuFileBatchIOGetStatus 

727 _check_or_init_cufile() 2 ctx1eg

728 if __cuFileBatchIOGetStatus == NULL: 2 ctx1eg

729 with gil: 

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

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

732 batch_idp, min_nr, nr, iocbp, timeout) 

733  

734  

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

736 global __cuFileBatchIOCancel 

737 _check_or_init_cufile() 1 ctx1f

738 if __cuFileBatchIOCancel == NULL: 1 ctx1f

739 with gil: 

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

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

742 batch_idp) 

743  

744  

745@_cyb_cython.show_performance_hints(False) (empty)

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

747 global __cuFileBatchIODestroy 

748 _check_or_init_cufile() 3 ctx1efg

749 if __cuFileBatchIODestroy == NULL: 3 ctx1efg

750 with gil: 

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

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

753 batch_idp) 

754  

755  

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

757 global __cuFileReadAsync 

758 _check_or_init_cufile() 2 ctx1hi

759 if __cuFileReadAsync == NULL: 2 ctx1hi

760 with gil: 

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

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

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

764  

765  

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

767 global __cuFileWriteAsync 

768 _check_or_init_cufile() 2 ctx1hj

769 if __cuFileWriteAsync == NULL: 2 ctx1hj

770 with gil: 

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

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

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

774  

775  

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

777 global __cuFileStreamRegister 

778 _check_or_init_cufile() 3 ctx1hij

779 if __cuFileStreamRegister == NULL: 3 ctx1hij

780 with gil: 

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

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

783 stream, flags) 

784  

785  

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

787 global __cuFileStreamDeregister 

788 _check_or_init_cufile() 3 ctx1hij

789 if __cuFileStreamDeregister == NULL: 3 ctx1hij

790 with gil: 

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

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

793 stream) 

794  

795  

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

797 global __cuFileGetVersion 

798 _check_or_init_cufile() 2 ctx1an

799 if __cuFileGetVersion == NULL: 2 ctx1an

800 with gil: 

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

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

803 version) 

804  

805  

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

807 global __cuFileGetParameterSizeT 

808 _check_or_init_cufile() 1 ctx1o

809 if __cuFileGetParameterSizeT == NULL: 1 ctx1o

810 with gil: 

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

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

813 param, value) 

814  

815  

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

817 global __cuFileGetParameterBool 

818 _check_or_init_cufile() 1 ctx1n

819 if __cuFileGetParameterBool == NULL: 1 ctx1n

820 with gil: 

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

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

823 param, value) 

824  

825  

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

827 global __cuFileGetParameterString 

828 _check_or_init_cufile() 1 ctx1p

829 if __cuFileGetParameterString == NULL: 1 ctx1p

830 with gil: 

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

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

833 param, desc_str, len) 

834  

835  

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

837 global __cuFileSetParameterSizeT 

838 _check_or_init_cufile() 1 ctx1o

839 if __cuFileSetParameterSizeT == NULL: 1 ctx1o

840 with gil: 

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

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

843 param, value) 

844  

845  

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

847 global __cuFileSetParameterBool 

848 _check_or_init_cufile() 1 ctx1n

849 if __cuFileSetParameterBool == NULL: 1 ctx1n

850 with gil: 

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

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

853 param, value) 

854  

855  

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

857 global __cuFileSetParameterString 

858 _check_or_init_cufile() 1 ctx1p

859 if __cuFileSetParameterString == NULL: 1 ctx1p

860 with gil: 

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

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

863 param, desc_str) 

864  

865  

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

867 global __cuFileGetParameterMinMaxValue 

868 _check_or_init_cufile() 1 ctx1,

869 if __cuFileGetParameterMinMaxValue == NULL: 1 ctx1,

870 with gil: 

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

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

873 param, min_value, max_value) 

874  

875  

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

877 global __cuFileSetStatsLevel 

878 _check_or_init_cufile() 10 ctx1bqcrdsJuvw

879 if __cuFileSetStatsLevel == NULL: 10 ctx1bqcrdsJuvw

880 with gil: 

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

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

883 level) 

884  

885  

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

887 global __cuFileGetStatsLevel 

888 _check_or_init_cufile() 6 ctx1DEFJKL

889 if __cuFileGetStatsLevel == NULL: 6 ctx1DEFJKL

890 with gil: 

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

892 return (<CUfileError_t (*)(int*) noexcept nogil>__cuFileGetStatsLevel)( 6 ctx1DEFJKL

893 level) 

894  

895  

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

897 global __cuFileStatsStart 

898 _check_or_init_cufile() 4 ctx1bcdv

899 if __cuFileStatsStart == NULL: 4 ctx1bcdv

900 with gil: 

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

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

903 ) 

904  

905  

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

907 global __cuFileStatsStop 

908 _check_or_init_cufile() 4 ctx1bcdv

909 if __cuFileStatsStop == NULL: 4 ctx1bcdv

910 with gil: 

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

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

913 ) 

914  

915  

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

917 global __cuFileStatsReset 

918 _check_or_init_cufile() 5 ctx1qrsuw

919 if __cuFileStatsReset == NULL: 5 ctx1qrsuw

920 with gil: 

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

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

923 ) 

924  

925  

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

927 global __cuFileGetStatsL1 

928 _check_or_init_cufile() 1 ctx1b

929 if __cuFileGetStatsL1 == NULL: 1 ctx1b

930 with gil: 

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

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

933 stats) 

934  

935  

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

937 global __cuFileGetStatsL2 

938 _check_or_init_cufile() 1 ctx1c

939 if __cuFileGetStatsL2 == NULL: 1 ctx1c

940 with gil: 

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

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

943 stats) 

944  

945  

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

947 global __cuFileGetStatsL3 

948 _check_or_init_cufile() 1 ctx1d

949 if __cuFileGetStatsL3 == NULL: 1 ctx1d

950 with gil: 

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

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

953 stats) 

954  

955  

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

957 global __cuFileGetBARSizeInKB 

958 _check_or_init_cufile() 1 ctx1)

959 if __cuFileGetBARSizeInKB == NULL: 1 ctx1)

960 with gil: 

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

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

963 gpuIndex, barSize) 

964  

965  

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

967 global __cuFileSetParameterPosixPoolSlabArray 

968 _check_or_init_cufile() 1 ctx1I

969 if __cuFileSetParameterPosixPoolSlabArray == NULL: 1 ctx1I

970 with gil: 

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

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

973 size_values, count_values, len) 

974  

975  

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

977 global __cuFileGetParameterPosixPoolSlabArray 

978 _check_or_init_cufile() 1 ctx1t

979 if __cuFileGetParameterPosixPoolSlabArray == NULL: 1 ctx1t

980 with gil: 

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

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

983 size_values, count_values, len)