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

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

2# 

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

4# 

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

6  

7from libc.stdint cimport intptr_t, uintptr_t 

8import threading 

9  

10from .utils import FunctionNotFoundError, NotSupportedError 

11  

12from cuda.pathfinder import load_nvidia_dynamic_lib 

13  

14import cython 

15  

16  

17############################################################################### 

18# Extern 

19############################################################################### 

20  

21# You must 'from .utils import NotSupportedError' before using this template 

22  

23cdef extern from "<dlfcn.h>" nogil: 

24 void* dlopen(const char*, int) 

25 char* dlerror() 

26 void* dlsym(void*, const char*) 

27 int dlclose(void*) 

28  

29 enum: 

30 RTLD_LAZY 

31 RTLD_NOW 

32 RTLD_GLOBAL 

33 RTLD_LOCAL 

34  

35 const void* RTLD_DEFAULT 'RTLD_DEFAULT' 

36  

37cdef int get_cuda_version(): 

38 cdef void* handle = NULL 

39 cdef int err, driver_ver = 0 

40  

41 # Load driver to check version 

42 handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) 

43 if handle == NULL: 

44 err_msg = dlerror() 

45 raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') 

46 cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") 

47 if cuDriverGetVersion == NULL: 

48 raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') 

49 err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver) 

50 if err != 0: 

51 raise RuntimeError(f'cuDriverGetVersion returned error code {err}') 

52  

53 return driver_ver 

54  

55  

56  

57############################################################################### 

58# Wrapper init 

59############################################################################### 

60  

61cdef object __symbol_lock = threading.Lock() 

62cdef bint __py_cufile_init = False 

63  

64cdef void* __cuFileHandleRegister = NULL 

65cdef void* __cuFileHandleDeregister = NULL 

66cdef void* __cuFileBufRegister = NULL 

67cdef void* __cuFileBufDeregister = NULL 

68cdef void* __cuFileRead = NULL 

69cdef void* __cuFileWrite = NULL 

70cdef void* __cuFileDriverOpen = NULL 

71cdef void* __cuFileDriverClose = NULL 

72cdef void* __cuFileDriverClose_v2 = NULL 

73cdef void* __cuFileUseCount = NULL 

74cdef void* __cuFileDriverGetProperties = NULL 

75cdef void* __cuFileDriverSetPollMode = NULL 

76cdef void* __cuFileDriverSetMaxDirectIOSize = NULL 

77cdef void* __cuFileDriverSetMaxCacheSize = NULL 

78cdef void* __cuFileDriverSetMaxPinnedMemSize = NULL 

79cdef void* __cuFileBatchIOSetUp = NULL 

80cdef void* __cuFileBatchIOSubmit = NULL 

81cdef void* __cuFileBatchIOGetStatus = NULL 

82cdef void* __cuFileBatchIOCancel = NULL 

83cdef void* __cuFileBatchIODestroy = NULL 

84cdef void* __cuFileReadAsync = NULL 

85cdef void* __cuFileWriteAsync = NULL 

86cdef void* __cuFileStreamRegister = NULL 

87cdef void* __cuFileStreamDeregister = NULL 

88cdef void* __cuFileGetVersion = NULL 

89cdef void* __cuFileGetParameterSizeT = NULL 

90cdef void* __cuFileGetParameterBool = NULL 

91cdef void* __cuFileGetParameterString = NULL 

92cdef void* __cuFileSetParameterSizeT = NULL 

93cdef void* __cuFileSetParameterBool = NULL 

94cdef void* __cuFileSetParameterString = NULL 

95cdef void* __cuFileGetParameterMinMaxValue = NULL 

96cdef void* __cuFileSetStatsLevel = NULL 

97cdef void* __cuFileGetStatsLevel = NULL 

98cdef void* __cuFileStatsStart = NULL 

99cdef void* __cuFileStatsStop = NULL 

100cdef void* __cuFileStatsReset = NULL 

101cdef void* __cuFileGetStatsL1 = NULL 

102cdef void* __cuFileGetStatsL2 = NULL 

103cdef void* __cuFileGetStatsL3 = NULL 

104cdef void* __cuFileGetBARSizeInKB = NULL 

105cdef void* __cuFileSetParameterPosixPoolSlabArray = NULL 

106cdef void* __cuFileGetParameterPosixPoolSlabArray = NULL 

107  

108  

109cdef void* load_library() except* with gil: 

110 cdef uintptr_t handle = load_nvidia_dynamic_lib("cufile")._handle_uint 

111 return <void*>handle 

112  

113  

114cdef int _init_cufile() except -1 nogil: 

115 global __py_cufile_init 

116  

117 cdef void* handle = NULL 

118  

119 with gil, __symbol_lock: 

120 # Recheck the flag after obtaining the locks 

121 if __py_cufile_init: 

122 return 0 

123 # Load function 

124 global __cuFileHandleRegister 

125 __cuFileHandleRegister = dlsym(RTLD_DEFAULT, 'cuFileHandleRegister') 

126 if __cuFileHandleRegister == NULL: 

127 if handle == NULL: 

128 handle = load_library() 

129 __cuFileHandleRegister = dlsym(handle, 'cuFileHandleRegister') 

130  

131 global __cuFileHandleDeregister 

132 __cuFileHandleDeregister = dlsym(RTLD_DEFAULT, 'cuFileHandleDeregister') 

133 if __cuFileHandleDeregister == NULL: 

134 if handle == NULL: 

135 handle = load_library() 

136 __cuFileHandleDeregister = dlsym(handle, 'cuFileHandleDeregister') 

137  

138 global __cuFileBufRegister 

139 __cuFileBufRegister = dlsym(RTLD_DEFAULT, 'cuFileBufRegister') 

140 if __cuFileBufRegister == NULL: 

141 if handle == NULL: 

142 handle = load_library() 

143 __cuFileBufRegister = dlsym(handle, 'cuFileBufRegister') 

144  

145 global __cuFileBufDeregister 

146 __cuFileBufDeregister = dlsym(RTLD_DEFAULT, 'cuFileBufDeregister') 

147 if __cuFileBufDeregister == NULL: 

148 if handle == NULL: 

149 handle = load_library() 

150 __cuFileBufDeregister = dlsym(handle, 'cuFileBufDeregister') 

151  

152 global __cuFileRead 

153 __cuFileRead = dlsym(RTLD_DEFAULT, 'cuFileRead') 

154 if __cuFileRead == NULL: 

155 if handle == NULL: 

156 handle = load_library() 

157 __cuFileRead = dlsym(handle, 'cuFileRead') 

158  

159 global __cuFileWrite 

160 __cuFileWrite = dlsym(RTLD_DEFAULT, 'cuFileWrite') 

161 if __cuFileWrite == NULL: 

162 if handle == NULL: 

163 handle = load_library() 

164 __cuFileWrite = dlsym(handle, 'cuFileWrite') 

165  

166 global __cuFileDriverOpen 

167 __cuFileDriverOpen = dlsym(RTLD_DEFAULT, 'cuFileDriverOpen') 

168 if __cuFileDriverOpen == NULL: 

169 if handle == NULL: 

170 handle = load_library() 

171 __cuFileDriverOpen = dlsym(handle, 'cuFileDriverOpen') 

172  

173 global __cuFileDriverClose 

174 __cuFileDriverClose = dlsym(RTLD_DEFAULT, 'cuFileDriverClose') 

175 if __cuFileDriverClose == NULL: 

176 if handle == NULL: 

177 handle = load_library() 

178 __cuFileDriverClose = dlsym(handle, 'cuFileDriverClose') 

179  

180 global __cuFileDriverClose_v2 

181 __cuFileDriverClose_v2 = dlsym(RTLD_DEFAULT, 'cuFileDriverClose_v2') 

182 if __cuFileDriverClose_v2 == NULL: 

183 if handle == NULL: 

184 handle = load_library() 

185 __cuFileDriverClose_v2 = dlsym(handle, 'cuFileDriverClose_v2') 

186  

187 global __cuFileUseCount 

188 __cuFileUseCount = dlsym(RTLD_DEFAULT, 'cuFileUseCount') 

189 if __cuFileUseCount == NULL: 

190 if handle == NULL: 

191 handle = load_library() 

192 __cuFileUseCount = dlsym(handle, 'cuFileUseCount') 

193  

194 global __cuFileDriverGetProperties 

195 __cuFileDriverGetProperties = dlsym(RTLD_DEFAULT, 'cuFileDriverGetProperties') 

196 if __cuFileDriverGetProperties == NULL: 

197 if handle == NULL: 

198 handle = load_library() 

199 __cuFileDriverGetProperties = dlsym(handle, 'cuFileDriverGetProperties') 

200  

201 global __cuFileDriverSetPollMode 

202 __cuFileDriverSetPollMode = dlsym(RTLD_DEFAULT, 'cuFileDriverSetPollMode') 

203 if __cuFileDriverSetPollMode == NULL: 

204 if handle == NULL: 

205 handle = load_library() 

206 __cuFileDriverSetPollMode = dlsym(handle, 'cuFileDriverSetPollMode') 

207  

208 global __cuFileDriverSetMaxDirectIOSize 

209 __cuFileDriverSetMaxDirectIOSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxDirectIOSize') 

210 if __cuFileDriverSetMaxDirectIOSize == NULL: 

211 if handle == NULL: 

212 handle = load_library() 

213 __cuFileDriverSetMaxDirectIOSize = dlsym(handle, 'cuFileDriverSetMaxDirectIOSize') 

214  

215 global __cuFileDriverSetMaxCacheSize 

216 __cuFileDriverSetMaxCacheSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxCacheSize') 

217 if __cuFileDriverSetMaxCacheSize == NULL: 

218 if handle == NULL: 

219 handle = load_library() 

220 __cuFileDriverSetMaxCacheSize = dlsym(handle, 'cuFileDriverSetMaxCacheSize') 

221  

222 global __cuFileDriverSetMaxPinnedMemSize 

223 __cuFileDriverSetMaxPinnedMemSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxPinnedMemSize') 

224 if __cuFileDriverSetMaxPinnedMemSize == NULL: 

225 if handle == NULL: 

226 handle = load_library() 

227 __cuFileDriverSetMaxPinnedMemSize = dlsym(handle, 'cuFileDriverSetMaxPinnedMemSize') 

228  

229 global __cuFileBatchIOSetUp 

230 __cuFileBatchIOSetUp = dlsym(RTLD_DEFAULT, 'cuFileBatchIOSetUp') 

231 if __cuFileBatchIOSetUp == NULL: 

232 if handle == NULL: 

233 handle = load_library() 

234 __cuFileBatchIOSetUp = dlsym(handle, 'cuFileBatchIOSetUp') 

235  

236 global __cuFileBatchIOSubmit 

237 __cuFileBatchIOSubmit = dlsym(RTLD_DEFAULT, 'cuFileBatchIOSubmit') 

238 if __cuFileBatchIOSubmit == NULL: 

239 if handle == NULL: 

240 handle = load_library() 

241 __cuFileBatchIOSubmit = dlsym(handle, 'cuFileBatchIOSubmit') 

242  

243 global __cuFileBatchIOGetStatus 

244 __cuFileBatchIOGetStatus = dlsym(RTLD_DEFAULT, 'cuFileBatchIOGetStatus') 

245 if __cuFileBatchIOGetStatus == NULL: 

246 if handle == NULL: 

247 handle = load_library() 

248 __cuFileBatchIOGetStatus = dlsym(handle, 'cuFileBatchIOGetStatus') 

249  

250 global __cuFileBatchIOCancel 

251 __cuFileBatchIOCancel = dlsym(RTLD_DEFAULT, 'cuFileBatchIOCancel') 

252 if __cuFileBatchIOCancel == NULL: 

253 if handle == NULL: 

254 handle = load_library() 

255 __cuFileBatchIOCancel = dlsym(handle, 'cuFileBatchIOCancel') 

256  

257 global __cuFileBatchIODestroy 

258 __cuFileBatchIODestroy = dlsym(RTLD_DEFAULT, 'cuFileBatchIODestroy') 

259 if __cuFileBatchIODestroy == NULL: 

260 if handle == NULL: 

261 handle = load_library() 

262 __cuFileBatchIODestroy = dlsym(handle, 'cuFileBatchIODestroy') 

263  

264 global __cuFileReadAsync 

265 __cuFileReadAsync = dlsym(RTLD_DEFAULT, 'cuFileReadAsync') 

266 if __cuFileReadAsync == NULL: 

267 if handle == NULL: 

268 handle = load_library() 

269 __cuFileReadAsync = dlsym(handle, 'cuFileReadAsync') 

270  

271 global __cuFileWriteAsync 

272 __cuFileWriteAsync = dlsym(RTLD_DEFAULT, 'cuFileWriteAsync') 

273 if __cuFileWriteAsync == NULL: 

274 if handle == NULL: 

275 handle = load_library() 

276 __cuFileWriteAsync = dlsym(handle, 'cuFileWriteAsync') 

277  

278 global __cuFileStreamRegister 

279 __cuFileStreamRegister = dlsym(RTLD_DEFAULT, 'cuFileStreamRegister') 

280 if __cuFileStreamRegister == NULL: 

281 if handle == NULL: 

282 handle = load_library() 

283 __cuFileStreamRegister = dlsym(handle, 'cuFileStreamRegister') 

284  

285 global __cuFileStreamDeregister 

286 __cuFileStreamDeregister = dlsym(RTLD_DEFAULT, 'cuFileStreamDeregister') 

287 if __cuFileStreamDeregister == NULL: 

288 if handle == NULL: 

289 handle = load_library() 

290 __cuFileStreamDeregister = dlsym(handle, 'cuFileStreamDeregister') 

291  

292 global __cuFileGetVersion 

293 __cuFileGetVersion = dlsym(RTLD_DEFAULT, 'cuFileGetVersion') 

294 if __cuFileGetVersion == NULL: 

295 if handle == NULL: 

296 handle = load_library() 

297 __cuFileGetVersion = dlsym(handle, 'cuFileGetVersion') 

298  

299 global __cuFileGetParameterSizeT 

300 __cuFileGetParameterSizeT = dlsym(RTLD_DEFAULT, 'cuFileGetParameterSizeT') 

301 if __cuFileGetParameterSizeT == NULL: 

302 if handle == NULL: 

303 handle = load_library() 

304 __cuFileGetParameterSizeT = dlsym(handle, 'cuFileGetParameterSizeT') 

305  

306 global __cuFileGetParameterBool 

307 __cuFileGetParameterBool = dlsym(RTLD_DEFAULT, 'cuFileGetParameterBool') 

308 if __cuFileGetParameterBool == NULL: 

309 if handle == NULL: 

310 handle = load_library() 

311 __cuFileGetParameterBool = dlsym(handle, 'cuFileGetParameterBool') 

312  

313 global __cuFileGetParameterString 

314 __cuFileGetParameterString = dlsym(RTLD_DEFAULT, 'cuFileGetParameterString') 

315 if __cuFileGetParameterString == NULL: 

316 if handle == NULL: 

317 handle = load_library() 

318 __cuFileGetParameterString = dlsym(handle, 'cuFileGetParameterString') 

319  

320 global __cuFileSetParameterSizeT 

321 __cuFileSetParameterSizeT = dlsym(RTLD_DEFAULT, 'cuFileSetParameterSizeT') 

322 if __cuFileSetParameterSizeT == NULL: 

323 if handle == NULL: 

324 handle = load_library() 

325 __cuFileSetParameterSizeT = dlsym(handle, 'cuFileSetParameterSizeT') 

326  

327 global __cuFileSetParameterBool 

328 __cuFileSetParameterBool = dlsym(RTLD_DEFAULT, 'cuFileSetParameterBool') 

329 if __cuFileSetParameterBool == NULL: 

330 if handle == NULL: 

331 handle = load_library() 

332 __cuFileSetParameterBool = dlsym(handle, 'cuFileSetParameterBool') 

333  

334 global __cuFileSetParameterString 

335 __cuFileSetParameterString = dlsym(RTLD_DEFAULT, 'cuFileSetParameterString') 

336 if __cuFileSetParameterString == NULL: 

337 if handle == NULL: 

338 handle = load_library() 

339 __cuFileSetParameterString = dlsym(handle, 'cuFileSetParameterString') 

340  

341 global __cuFileGetParameterMinMaxValue 

342 __cuFileGetParameterMinMaxValue = dlsym(RTLD_DEFAULT, 'cuFileGetParameterMinMaxValue') 

343 if __cuFileGetParameterMinMaxValue == NULL: 

344 if handle == NULL: 

345 handle = load_library() 

346 __cuFileGetParameterMinMaxValue = dlsym(handle, 'cuFileGetParameterMinMaxValue') 

347  

348 global __cuFileSetStatsLevel 

349 __cuFileSetStatsLevel = dlsym(RTLD_DEFAULT, 'cuFileSetStatsLevel') 

350 if __cuFileSetStatsLevel == NULL: 

351 if handle == NULL: 

352 handle = load_library() 

353 __cuFileSetStatsLevel = dlsym(handle, 'cuFileSetStatsLevel') 

354  

355 global __cuFileGetStatsLevel 

356 __cuFileGetStatsLevel = dlsym(RTLD_DEFAULT, 'cuFileGetStatsLevel') 

357 if __cuFileGetStatsLevel == NULL: 

358 if handle == NULL: 

359 handle = load_library() 

360 __cuFileGetStatsLevel = dlsym(handle, 'cuFileGetStatsLevel') 

361  

362 global __cuFileStatsStart 

363 __cuFileStatsStart = dlsym(RTLD_DEFAULT, 'cuFileStatsStart') 

364 if __cuFileStatsStart == NULL: 

365 if handle == NULL: 

366 handle = load_library() 

367 __cuFileStatsStart = dlsym(handle, 'cuFileStatsStart') 

368  

369 global __cuFileStatsStop 

370 __cuFileStatsStop = dlsym(RTLD_DEFAULT, 'cuFileStatsStop') 

371 if __cuFileStatsStop == NULL: 

372 if handle == NULL: 

373 handle = load_library() 

374 __cuFileStatsStop = dlsym(handle, 'cuFileStatsStop') 

375  

376 global __cuFileStatsReset 

377 __cuFileStatsReset = dlsym(RTLD_DEFAULT, 'cuFileStatsReset') 

378 if __cuFileStatsReset == NULL: 

379 if handle == NULL: 

380 handle = load_library() 

381 __cuFileStatsReset = dlsym(handle, 'cuFileStatsReset') 

382  

383 global __cuFileGetStatsL1 

384 __cuFileGetStatsL1 = dlsym(RTLD_DEFAULT, 'cuFileGetStatsL1') 

385 if __cuFileGetStatsL1 == NULL: 

386 if handle == NULL: 

387 handle = load_library() 

388 __cuFileGetStatsL1 = dlsym(handle, 'cuFileGetStatsL1') 

389  

390 global __cuFileGetStatsL2 

391 __cuFileGetStatsL2 = dlsym(RTLD_DEFAULT, 'cuFileGetStatsL2') 

392 if __cuFileGetStatsL2 == NULL: 

393 if handle == NULL: 

394 handle = load_library() 

395 __cuFileGetStatsL2 = dlsym(handle, 'cuFileGetStatsL2') 

396  

397 global __cuFileGetStatsL3 

398 __cuFileGetStatsL3 = dlsym(RTLD_DEFAULT, 'cuFileGetStatsL3') 

399 if __cuFileGetStatsL3 == NULL: 

400 if handle == NULL: 

401 handle = load_library() 

402 __cuFileGetStatsL3 = dlsym(handle, 'cuFileGetStatsL3') 

403  

404 global __cuFileGetBARSizeInKB 

405 __cuFileGetBARSizeInKB = dlsym(RTLD_DEFAULT, 'cuFileGetBARSizeInKB') 

406 if __cuFileGetBARSizeInKB == NULL: 

407 if handle == NULL: 

408 handle = load_library() 

409 __cuFileGetBARSizeInKB = dlsym(handle, 'cuFileGetBARSizeInKB') 

410  

411 global __cuFileSetParameterPosixPoolSlabArray 

412 __cuFileSetParameterPosixPoolSlabArray = dlsym(RTLD_DEFAULT, 'cuFileSetParameterPosixPoolSlabArray') 

413 if __cuFileSetParameterPosixPoolSlabArray == NULL: 

414 if handle == NULL: 

415 handle = load_library() 

416 __cuFileSetParameterPosixPoolSlabArray = dlsym(handle, 'cuFileSetParameterPosixPoolSlabArray') 

417  

418 global __cuFileGetParameterPosixPoolSlabArray 

419 __cuFileGetParameterPosixPoolSlabArray = dlsym(RTLD_DEFAULT, 'cuFileGetParameterPosixPoolSlabArray') 

420 if __cuFileGetParameterPosixPoolSlabArray == NULL: 

421 if handle == NULL: 

422 handle = load_library() 

423 __cuFileGetParameterPosixPoolSlabArray = dlsym(handle, 'cuFileGetParameterPosixPoolSlabArray') 

424  

425 __py_cufile_init = True 

426 return 0 

427  

428  

429cdef inline int _check_or_init_cufile() except -1 nogil: 

430 if __py_cufile_init: 

431 return 0 

432  

433 return _init_cufile() 

434  

435  

436cdef dict func_ptrs = None 

437  

438  

439cpdef dict _inspect_function_pointers(): 

440 global func_ptrs 

441 if func_ptrs is not None: 

442 return func_ptrs 

443  

444 _check_or_init_cufile() 

445 cdef dict data = {} 

446  

447 global __cuFileHandleRegister 

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

449  

450 global __cuFileHandleDeregister 

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

452  

453 global __cuFileBufRegister 

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

455  

456 global __cuFileBufDeregister 

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

458  

459 global __cuFileRead 

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

461  

462 global __cuFileWrite 

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

464  

465 global __cuFileDriverOpen 

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

467  

468 global __cuFileDriverClose 

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

470  

471 global __cuFileDriverClose_v2 

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

473  

474 global __cuFileUseCount 

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

476  

477 global __cuFileDriverGetProperties 

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

479  

480 global __cuFileDriverSetPollMode 

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

482  

483 global __cuFileDriverSetMaxDirectIOSize 

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

485  

486 global __cuFileDriverSetMaxCacheSize 

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

488  

489 global __cuFileDriverSetMaxPinnedMemSize 

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

491  

492 global __cuFileBatchIOSetUp 

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

494  

495 global __cuFileBatchIOSubmit 

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

497  

498 global __cuFileBatchIOGetStatus 

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

500  

501 global __cuFileBatchIOCancel 

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

503  

504 global __cuFileBatchIODestroy 

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

506  

507 global __cuFileReadAsync 

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

509  

510 global __cuFileWriteAsync 

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

512  

513 global __cuFileStreamRegister 

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

515  

516 global __cuFileStreamDeregister 

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

518  

519 global __cuFileGetVersion 

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

521  

522 global __cuFileGetParameterSizeT 

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

524  

525 global __cuFileGetParameterBool 

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

527  

528 global __cuFileGetParameterString 

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

530  

531 global __cuFileSetParameterSizeT 

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

533  

534 global __cuFileSetParameterBool 

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

536  

537 global __cuFileSetParameterString 

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

539  

540 global __cuFileGetParameterMinMaxValue 

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

542  

543 global __cuFileSetStatsLevel 

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

545  

546 global __cuFileGetStatsLevel 

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

548  

549 global __cuFileStatsStart 

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

551  

552 global __cuFileStatsStop 

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

554  

555 global __cuFileStatsReset 

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

557  

558 global __cuFileGetStatsL1 

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

560  

561 global __cuFileGetStatsL2 

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

563  

564 global __cuFileGetStatsL3 

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

566  

567 global __cuFileGetBARSizeInKB 

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

569  

570 global __cuFileSetParameterPosixPoolSlabArray 

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

572  

573 global __cuFileGetParameterPosixPoolSlabArray 

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

575  

576 func_ptrs = data 

577 return data 

578  

579  

580cpdef _inspect_function_pointer(str name): 

581 global func_ptrs 

582 if func_ptrs is None: 

583 func_ptrs = _inspect_function_pointers() 

584 return func_ptrs[name] 

585  

586  

587############################################################################### 

588# Wrapper functions 

589############################################################################### 

590  

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

592 global __cuFileHandleRegister 

593 _check_or_init_cufile() 

594 if __cuFileHandleRegister == NULL: 

595 with gil: 

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

597 return (<CUfileError_t (*)(CUfileHandle_t*, CUfileDescr_t*) noexcept nogil>__cuFileHandleRegister)( 

598 fh, descr) 

599  

600  

601@cython.show_performance_hints(False) 

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

603 global __cuFileHandleDeregister 

604 _check_or_init_cufile() 

605 if __cuFileHandleDeregister == NULL: 

606 with gil: 

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

608 (<void (*)(CUfileHandle_t) noexcept nogil>__cuFileHandleDeregister)( 

609 fh) 

610  

611  

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

613 global __cuFileBufRegister 

614 _check_or_init_cufile() 

615 if __cuFileBufRegister == NULL: 

616 with gil: 

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

618 return (<CUfileError_t (*)(const void*, size_t, int) noexcept nogil>__cuFileBufRegister)( 

619 bufPtr_base, length, flags) 

620  

621  

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

623 global __cuFileBufDeregister 

624 _check_or_init_cufile() 

625 if __cuFileBufDeregister == NULL: 

626 with gil: 

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

628 return (<CUfileError_t (*)(const void*) noexcept nogil>__cuFileBufDeregister)( 

629 bufPtr_base) 

630  

631  

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

633 global __cuFileRead 

634 _check_or_init_cufile() 

635 if __cuFileRead == NULL: 

636 with gil: 

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

638 return (<ssize_t (*)(CUfileHandle_t, void*, size_t, off_t, off_t) noexcept nogil>__cuFileRead)( 

639 fh, bufPtr_base, size, file_offset, bufPtr_offset) 

640  

641  

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

643 global __cuFileWrite 

644 _check_or_init_cufile() 

645 if __cuFileWrite == NULL: 

646 with gil: 

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

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

649 fh, bufPtr_base, size, file_offset, bufPtr_offset) 

650  

651  

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

653 global __cuFileDriverOpen 

654 _check_or_init_cufile() 

655 if __cuFileDriverOpen == NULL: 

656 with gil: 

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

658 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverOpen)( 

659 ) 

660  

661  

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

663 global __cuFileDriverClose 

664 _check_or_init_cufile() 

665 if __cuFileDriverClose == NULL: 

666 with gil: 

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

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

669 ) 

670  

671  

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

673 global __cuFileDriverClose_v2 

674 _check_or_init_cufile() 

675 if __cuFileDriverClose_v2 == NULL: 

676 with gil: 

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

678 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverClose_v2)( 

679 ) 

680  

681  

682cdef long _cuFileUseCount() except* nogil: 

683 global __cuFileUseCount 

684 _check_or_init_cufile() 

685 if __cuFileUseCount == NULL: 

686 with gil: 

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

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

689 ) 

690  

691  

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

693 global __cuFileDriverGetProperties 

694 _check_or_init_cufile() 

695 if __cuFileDriverGetProperties == NULL: 

696 with gil: 

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

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

699 props) 

700  

701  

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

703 global __cuFileDriverSetPollMode 

704 _check_or_init_cufile() 

705 if __cuFileDriverSetPollMode == NULL: 

706 with gil: 

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

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

709 poll, poll_threshold_size) 

710  

711  

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

713 global __cuFileDriverSetMaxDirectIOSize 

714 _check_or_init_cufile() 

715 if __cuFileDriverSetMaxDirectIOSize == NULL: 

716 with gil: 

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

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

719 max_direct_io_size) 

720  

721  

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

723 global __cuFileDriverSetMaxCacheSize 

724 _check_or_init_cufile() 

725 if __cuFileDriverSetMaxCacheSize == NULL: 

726 with gil: 

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

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

729 max_cache_size) 

730  

731  

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

733 global __cuFileDriverSetMaxPinnedMemSize 

734 _check_or_init_cufile() 

735 if __cuFileDriverSetMaxPinnedMemSize == NULL: 

736 with gil: 

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

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

739 max_pinned_size) 

740  

741  

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

743 global __cuFileBatchIOSetUp 

744 _check_or_init_cufile() 

745 if __cuFileBatchIOSetUp == NULL: 

746 with gil: 

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

748 return (<CUfileError_t (*)(CUfileBatchHandle_t*, unsigned) noexcept nogil>__cuFileBatchIOSetUp)( 

749 batch_idp, nr) 

750  

751  

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

753 global __cuFileBatchIOSubmit 

754 _check_or_init_cufile() 

755 if __cuFileBatchIOSubmit == NULL: 

756 with gil: 

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

758 return (<CUfileError_t (*)(CUfileBatchHandle_t, unsigned, CUfileIOParams_t*, unsigned int) noexcept nogil>__cuFileBatchIOSubmit)( 

759 batch_idp, nr, iocbp, flags) 

760  

761  

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

763 global __cuFileBatchIOGetStatus 

764 _check_or_init_cufile() 

765 if __cuFileBatchIOGetStatus == NULL: 

766 with gil: 

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

768 return (<CUfileError_t (*)(CUfileBatchHandle_t, unsigned, unsigned*, CUfileIOEvents_t*, timespec*) noexcept nogil>__cuFileBatchIOGetStatus)( 

769 batch_idp, min_nr, nr, iocbp, timeout) 

770  

771  

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

773 global __cuFileBatchIOCancel 

774 _check_or_init_cufile() 

775 if __cuFileBatchIOCancel == NULL: 

776 with gil: 

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

778 return (<CUfileError_t (*)(CUfileBatchHandle_t) noexcept nogil>__cuFileBatchIOCancel)( 

779 batch_idp) 

780  

781  

782@cython.show_performance_hints(False) 

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

784 global __cuFileBatchIODestroy 

785 _check_or_init_cufile() 

786 if __cuFileBatchIODestroy == NULL: 

787 with gil: 

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

789 (<void (*)(CUfileBatchHandle_t) noexcept nogil>__cuFileBatchIODestroy)( 

790 batch_idp) 

791  

792  

793cdef 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: 

794 global __cuFileReadAsync 

795 _check_or_init_cufile() 

796 if __cuFileReadAsync == NULL: 

797 with gil: 

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

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

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

801  

802  

803cdef 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: 

804 global __cuFileWriteAsync 

805 _check_or_init_cufile() 

806 if __cuFileWriteAsync == NULL: 

807 with gil: 

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

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

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

811  

812  

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

814 global __cuFileStreamRegister 

815 _check_or_init_cufile() 

816 if __cuFileStreamRegister == NULL: 

817 with gil: 

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

819 return (<CUfileError_t (*)(CUstream, unsigned) noexcept nogil>__cuFileStreamRegister)( 

820 stream, flags) 

821  

822  

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

824 global __cuFileStreamDeregister 

825 _check_or_init_cufile() 

826 if __cuFileStreamDeregister == NULL: 

827 with gil: 

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

829 return (<CUfileError_t (*)(CUstream) noexcept nogil>__cuFileStreamDeregister)( 

830 stream) 

831  

832  

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

834 global __cuFileGetVersion 

835 _check_or_init_cufile() 

836 if __cuFileGetVersion == NULL: 

837 with gil: 

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

839 return (<CUfileError_t (*)(int*) noexcept nogil>__cuFileGetVersion)( 

840 version) 

841  

842  

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

844 global __cuFileGetParameterSizeT 

845 _check_or_init_cufile() 

846 if __cuFileGetParameterSizeT == NULL: 

847 with gil: 

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

849 return (<CUfileError_t (*)(CUFileSizeTConfigParameter_t, size_t*) noexcept nogil>__cuFileGetParameterSizeT)( 

850 param, value) 

851  

852  

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

854 global __cuFileGetParameterBool 

855 _check_or_init_cufile() 

856 if __cuFileGetParameterBool == NULL: 

857 with gil: 

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

859 return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, cpp_bool*) noexcept nogil>__cuFileGetParameterBool)( 

860 param, value) 

861  

862  

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

864 global __cuFileGetParameterString 

865 _check_or_init_cufile() 

866 if __cuFileGetParameterString == NULL: 

867 with gil: 

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

869 return (<CUfileError_t (*)(CUFileStringConfigParameter_t, char*, int) noexcept nogil>__cuFileGetParameterString)( 

870 param, desc_str, len) 

871  

872  

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

874 global __cuFileSetParameterSizeT 

875 _check_or_init_cufile() 

876 if __cuFileSetParameterSizeT == NULL: 

877 with gil: 

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

879 return (<CUfileError_t (*)(CUFileSizeTConfigParameter_t, size_t) noexcept nogil>__cuFileSetParameterSizeT)( 

880 param, value) 

881  

882  

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

884 global __cuFileSetParameterBool 

885 _check_or_init_cufile() 

886 if __cuFileSetParameterBool == NULL: 

887 with gil: 

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

889 return (<CUfileError_t (*)(CUFileBoolConfigParameter_t, cpp_bool) noexcept nogil>__cuFileSetParameterBool)( 

890 param, value) 

891  

892  

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

894 global __cuFileSetParameterString 

895 _check_or_init_cufile() 

896 if __cuFileSetParameterString == NULL: 

897 with gil: 

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

899 return (<CUfileError_t (*)(CUFileStringConfigParameter_t, const char*) noexcept nogil>__cuFileSetParameterString)( 

900 param, desc_str) 

901  

902  

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

904 global __cuFileGetParameterMinMaxValue 

905 _check_or_init_cufile() 

906 if __cuFileGetParameterMinMaxValue == NULL: 

907 with gil: 

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

909 return (<CUfileError_t (*)(CUFileSizeTConfigParameter_t, size_t*, size_t*) noexcept nogil>__cuFileGetParameterMinMaxValue)( 

910 param, min_value, max_value) 

911  

912  

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

914 global __cuFileSetStatsLevel 

915 _check_or_init_cufile() 

916 if __cuFileSetStatsLevel == NULL: 

917 with gil: 

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

919 return (<CUfileError_t (*)(int) noexcept nogil>__cuFileSetStatsLevel)( 

920 level) 

921  

922  

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

924 global __cuFileGetStatsLevel 

925 _check_or_init_cufile() 

926 if __cuFileGetStatsLevel == NULL: 

927 with gil: 

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

929 return (<CUfileError_t (*)(int*) noexcept nogil>__cuFileGetStatsLevel)( 

930 level) 

931  

932  

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

934 global __cuFileStatsStart 

935 _check_or_init_cufile() 

936 if __cuFileStatsStart == NULL: 

937 with gil: 

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

939 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsStart)( 

940 ) 

941  

942  

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

944 global __cuFileStatsStop 

945 _check_or_init_cufile() 

946 if __cuFileStatsStop == NULL: 

947 with gil: 

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

949 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsStop)( 

950 ) 

951  

952  

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

954 global __cuFileStatsReset 

955 _check_or_init_cufile() 

956 if __cuFileStatsReset == NULL: 

957 with gil: 

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

959 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsReset)( 

960 ) 

961  

962  

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

964 global __cuFileGetStatsL1 

965 _check_or_init_cufile() 

966 if __cuFileGetStatsL1 == NULL: 

967 with gil: 

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

969 return (<CUfileError_t (*)(CUfileStatsLevel1_t*) noexcept nogil>__cuFileGetStatsL1)( 

970 stats) 

971  

972  

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

974 global __cuFileGetStatsL2 

975 _check_or_init_cufile() 

976 if __cuFileGetStatsL2 == NULL: 

977 with gil: 

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

979 return (<CUfileError_t (*)(CUfileStatsLevel2_t*) noexcept nogil>__cuFileGetStatsL2)( 

980 stats) 

981  

982  

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

984 global __cuFileGetStatsL3 

985 _check_or_init_cufile() 

986 if __cuFileGetStatsL3 == NULL: 

987 with gil: 

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

989 return (<CUfileError_t (*)(CUfileStatsLevel3_t*) noexcept nogil>__cuFileGetStatsL3)( 

990 stats) 

991  

992  

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

994 global __cuFileGetBARSizeInKB 

995 _check_or_init_cufile() 

996 if __cuFileGetBARSizeInKB == NULL: 

997 with gil: 

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

999 return (<CUfileError_t (*)(int, size_t*) noexcept nogil>__cuFileGetBARSizeInKB)( 

1000 gpuIndex, barSize) 

1001  

1002  

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

1004 global __cuFileSetParameterPosixPoolSlabArray 

1005 _check_or_init_cufile() 

1006 if __cuFileSetParameterPosixPoolSlabArray == NULL: 

1007 with gil: 

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

1009 return (<CUfileError_t (*)(const size_t*, const size_t*, int) noexcept nogil>__cuFileSetParameterPosixPoolSlabArray)( 

1010 size_values, count_values, len) 

1011  

1012  

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

1014 global __cuFileGetParameterPosixPoolSlabArray 

1015 _check_or_init_cufile() 

1016 if __cuFileGetParameterPosixPoolSlabArray == NULL: 

1017 with gil: 

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

1019 return (<CUfileError_t (*)(size_t*, size_t*, int) noexcept nogil>__cuFileGetParameterPosixPoolSlabArray)( 

1020 size_values, count_values, len)