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

3# SPDX-License-Identifier: Apache-2.0

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

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

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

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

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

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

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

45 const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT"

47cimport cython as _cyb_cython

48from libc.stdint cimport intptr_t

49from libcpp cimport bool as _cyb_bool

51import threading as _cyb_threading (empty)

53cdef int _cyb___py_cufile_init = 0 (empty)

54cdef dict _cyb_func_ptrs = None (empty)

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

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

59from libc.stdint cimport uintptr_t

61from .utils import FunctionNotFoundError, NotSupportedError (empty)

62from cuda.pathfinder import load_nvidia_dynamic_lib (empty)

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

66# Wrapper init

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

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)

113cdef void* __cuFileReadv = NULL (empty)

114cdef void* __cuFileWritev = NULL (empty)

115

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

117 global _cyb___py_cufile_init

118 cdef void* handle = NULL (empty)

119 with gil, _cyb_symbol_lock: (empty)

120 if _cyb___py_cufile_init: return 0 (empty)

121

122 global __cuFileHandleRegister

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

124 if __cuFileHandleRegister == NULL: (empty)

125 if handle == NULL: (empty)

126 handle = load_library() (empty)

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

128

129 global __cuFileHandleDeregister

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

131 if __cuFileHandleDeregister == NULL: (empty)

132 if handle == NULL:

133 handle = load_library()

134 __cuFileHandleDeregister = _cyb_dlsym(handle, 'cuFileHandleDeregister')

135

136 global __cuFileBufRegister

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

138 if __cuFileBufRegister == NULL: (empty)

139 if handle == NULL:

140 handle = load_library()

141 __cuFileBufRegister = _cyb_dlsym(handle, 'cuFileBufRegister')

142

143 global __cuFileBufDeregister

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

145 if __cuFileBufDeregister == NULL: (empty)

146 if handle == NULL:

147 handle = load_library()

148 __cuFileBufDeregister = _cyb_dlsym(handle, 'cuFileBufDeregister')

149

150 global __cuFileRead

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

152 if __cuFileRead == NULL: (empty)

153 if handle == NULL:

154 handle = load_library()

155 __cuFileRead = _cyb_dlsym(handle, 'cuFileRead')

156

157 global __cuFileWrite

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

159 if __cuFileWrite == NULL: (empty)

160 if handle == NULL:

161 handle = load_library()

162 __cuFileWrite = _cyb_dlsym(handle, 'cuFileWrite')

163

164 global __cuFileDriverOpen

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

166 if __cuFileDriverOpen == NULL: (empty)

167 if handle == NULL:

168 handle = load_library()

169 __cuFileDriverOpen = _cyb_dlsym(handle, 'cuFileDriverOpen')

170

171 global __cuFileDriverClose

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

173 if __cuFileDriverClose == NULL: (empty)

174 if handle == NULL:

175 handle = load_library()

176 __cuFileDriverClose = _cyb_dlsym(handle, 'cuFileDriverClose')

177

178 global __cuFileDriverClose_v2

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

180 if __cuFileDriverClose_v2 == NULL: (empty)

181 if handle == NULL:

182 handle = load_library()

183 __cuFileDriverClose_v2 = _cyb_dlsym(handle, 'cuFileDriverClose_v2')

184

185 global __cuFileUseCount

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

187 if __cuFileUseCount == NULL: (empty)

188 if handle == NULL:

189 handle = load_library()

190 __cuFileUseCount = _cyb_dlsym(handle, 'cuFileUseCount')

191

192 global __cuFileDriverGetProperties

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

194 if __cuFileDriverGetProperties == NULL: (empty)

195 if handle == NULL:

196 handle = load_library()

197 __cuFileDriverGetProperties = _cyb_dlsym(handle, 'cuFileDriverGetProperties')

198

199 global __cuFileDriverSetPollMode

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

201 if __cuFileDriverSetPollMode == NULL: (empty)

202 if handle == NULL:

203 handle = load_library()

204 __cuFileDriverSetPollMode = _cyb_dlsym(handle, 'cuFileDriverSetPollMode')

205

206 global __cuFileDriverSetMaxDirectIOSize

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

208 if __cuFileDriverSetMaxDirectIOSize == NULL: (empty)

209 if handle == NULL:

210 handle = load_library()

211 __cuFileDriverSetMaxDirectIOSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxDirectIOSize')

212

213 global __cuFileDriverSetMaxCacheSize

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

215 if __cuFileDriverSetMaxCacheSize == NULL: (empty)

216 if handle == NULL:

217 handle = load_library()

218 __cuFileDriverSetMaxCacheSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxCacheSize')

219

220 global __cuFileDriverSetMaxPinnedMemSize

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

222 if __cuFileDriverSetMaxPinnedMemSize == NULL: (empty)

223 if handle == NULL:

224 handle = load_library()

225 __cuFileDriverSetMaxPinnedMemSize = _cyb_dlsym(handle, 'cuFileDriverSetMaxPinnedMemSize')

226

227 global __cuFileBatchIOSetUp

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

229 if __cuFileBatchIOSetUp == NULL: (empty)

230 if handle == NULL:

231 handle = load_library()

232 __cuFileBatchIOSetUp = _cyb_dlsym(handle, 'cuFileBatchIOSetUp')

233

234 global __cuFileBatchIOSubmit

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

236 if __cuFileBatchIOSubmit == NULL: (empty)

237 if handle == NULL:

238 handle = load_library()

239 __cuFileBatchIOSubmit = _cyb_dlsym(handle, 'cuFileBatchIOSubmit')

240

241 global __cuFileBatchIOGetStatus

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

243 if __cuFileBatchIOGetStatus == NULL: (empty)

244 if handle == NULL:

245 handle = load_library()

246 __cuFileBatchIOGetStatus = _cyb_dlsym(handle, 'cuFileBatchIOGetStatus')

247

248 global __cuFileBatchIOCancel

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

250 if __cuFileBatchIOCancel == NULL: (empty)

251 if handle == NULL:

252 handle = load_library()

253 __cuFileBatchIOCancel = _cyb_dlsym(handle, 'cuFileBatchIOCancel')

254

255 global __cuFileBatchIODestroy

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

257 if __cuFileBatchIODestroy == NULL: (empty)

258 if handle == NULL:

259 handle = load_library()

260 __cuFileBatchIODestroy = _cyb_dlsym(handle, 'cuFileBatchIODestroy')

261

262 global __cuFileReadAsync

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

264 if __cuFileReadAsync == NULL: (empty)

265 if handle == NULL:

266 handle = load_library()

267 __cuFileReadAsync = _cyb_dlsym(handle, 'cuFileReadAsync')

268

269 global __cuFileWriteAsync

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

271 if __cuFileWriteAsync == NULL: (empty)

272 if handle == NULL:

273 handle = load_library()

274 __cuFileWriteAsync = _cyb_dlsym(handle, 'cuFileWriteAsync')

275

276 global __cuFileStreamRegister

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

278 if __cuFileStreamRegister == NULL: (empty)

279 if handle == NULL:

280 handle = load_library()

281 __cuFileStreamRegister = _cyb_dlsym(handle, 'cuFileStreamRegister')

282

283 global __cuFileStreamDeregister

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

285 if __cuFileStreamDeregister == NULL: (empty)

286 if handle == NULL:

287 handle = load_library()

288 __cuFileStreamDeregister = _cyb_dlsym(handle, 'cuFileStreamDeregister')

289

290 global __cuFileGetVersion

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

292 if __cuFileGetVersion == NULL: (empty)

293 if handle == NULL:

294 handle = load_library()

295 __cuFileGetVersion = _cyb_dlsym(handle, 'cuFileGetVersion')

296

297 global __cuFileGetParameterSizeT

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

299 if __cuFileGetParameterSizeT == NULL: (empty)

300 if handle == NULL:

301 handle = load_library()

302 __cuFileGetParameterSizeT = _cyb_dlsym(handle, 'cuFileGetParameterSizeT')

303

304 global __cuFileGetParameterBool

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

306 if __cuFileGetParameterBool == NULL: (empty)

307 if handle == NULL:

308 handle = load_library()

309 __cuFileGetParameterBool = _cyb_dlsym(handle, 'cuFileGetParameterBool')

310

311 global __cuFileGetParameterString

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

313 if __cuFileGetParameterString == NULL: (empty)

314 if handle == NULL:

315 handle = load_library()

316 __cuFileGetParameterString = _cyb_dlsym(handle, 'cuFileGetParameterString')

317

318 global __cuFileSetParameterSizeT

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

320 if __cuFileSetParameterSizeT == NULL: (empty)

321 if handle == NULL:

322 handle = load_library()

323 __cuFileSetParameterSizeT = _cyb_dlsym(handle, 'cuFileSetParameterSizeT')

324

325 global __cuFileSetParameterBool

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

327 if __cuFileSetParameterBool == NULL: (empty)

328 if handle == NULL:

329 handle = load_library()

330 __cuFileSetParameterBool = _cyb_dlsym(handle, 'cuFileSetParameterBool')

331

332 global __cuFileSetParameterString

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

334 if __cuFileSetParameterString == NULL: (empty)

335 if handle == NULL:

336 handle = load_library()

337 __cuFileSetParameterString = _cyb_dlsym(handle, 'cuFileSetParameterString')

338

339 global __cuFileGetParameterMinMaxValue

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

341 if __cuFileGetParameterMinMaxValue == NULL: (empty)

342 if handle == NULL:

343 handle = load_library()

344 __cuFileGetParameterMinMaxValue = _cyb_dlsym(handle, 'cuFileGetParameterMinMaxValue')

345

346 global __cuFileSetStatsLevel

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

348 if __cuFileSetStatsLevel == NULL: (empty)

349 if handle == NULL:

350 handle = load_library()

351 __cuFileSetStatsLevel = _cyb_dlsym(handle, 'cuFileSetStatsLevel')

352

353 global __cuFileGetStatsLevel

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

355 if __cuFileGetStatsLevel == NULL: (empty)

356 if handle == NULL:

357 handle = load_library()

358 __cuFileGetStatsLevel = _cyb_dlsym(handle, 'cuFileGetStatsLevel')

359

360 global __cuFileStatsStart

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

362 if __cuFileStatsStart == NULL: (empty)

363 if handle == NULL:

364 handle = load_library()

365 __cuFileStatsStart = _cyb_dlsym(handle, 'cuFileStatsStart')

366

367 global __cuFileStatsStop

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

369 if __cuFileStatsStop == NULL: (empty)

370 if handle == NULL:

371 handle = load_library()

372 __cuFileStatsStop = _cyb_dlsym(handle, 'cuFileStatsStop')

373

374 global __cuFileStatsReset

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

376 if __cuFileStatsReset == NULL: (empty)

377 if handle == NULL:

378 handle = load_library()

379 __cuFileStatsReset = _cyb_dlsym(handle, 'cuFileStatsReset')

380

381 global __cuFileGetStatsL1

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

383 if __cuFileGetStatsL1 == NULL: (empty)

384 if handle == NULL:

385 handle = load_library()

386 __cuFileGetStatsL1 = _cyb_dlsym(handle, 'cuFileGetStatsL1')

387

388 global __cuFileGetStatsL2

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

390 if __cuFileGetStatsL2 == NULL: (empty)

391 if handle == NULL:

392 handle = load_library()

393 __cuFileGetStatsL2 = _cyb_dlsym(handle, 'cuFileGetStatsL2')

394

395 global __cuFileGetStatsL3

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

397 if __cuFileGetStatsL3 == NULL: (empty)

398 if handle == NULL:

399 handle = load_library()

400 __cuFileGetStatsL3 = _cyb_dlsym(handle, 'cuFileGetStatsL3')

401

402 global __cuFileGetBARSizeInKB

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

404 if __cuFileGetBARSizeInKB == NULL: (empty)

405 if handle == NULL:

406 handle = load_library()

407 __cuFileGetBARSizeInKB = _cyb_dlsym(handle, 'cuFileGetBARSizeInKB')

408

409 global __cuFileSetParameterPosixPoolSlabArray

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

411 if __cuFileSetParameterPosixPoolSlabArray == NULL: (empty)

412 if handle == NULL:

413 handle = load_library()

414 __cuFileSetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileSetParameterPosixPoolSlabArray')

415

416 global __cuFileGetParameterPosixPoolSlabArray

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

418 if __cuFileGetParameterPosixPoolSlabArray == NULL: (empty)

419 if handle == NULL:

420 handle = load_library()

421 __cuFileGetParameterPosixPoolSlabArray = _cyb_dlsym(handle, 'cuFileGetParameterPosixPoolSlabArray')

422

423 global __cuFileReadv

424 __cuFileReadv = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileReadv') (empty)

425 if __cuFileReadv == NULL: (empty)

426 if handle == NULL:

427 handle = load_library()

428 __cuFileReadv = _cyb_dlsym(handle, 'cuFileReadv')

429

430 global __cuFileWritev

431 __cuFileWritev = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'cuFileWritev') (empty)

432 if __cuFileWritev == NULL: (empty)

433 if handle == NULL:

434 handle = load_library()

435 __cuFileWritev = _cyb_dlsym(handle, 'cuFileWritev')

436

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

438 return 0 (empty)

439

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

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

442 return 0 76 ctx1aeLMfNOgPQyRSzTUAVWBXYCZ0D12h34i56k78l9!m#$j%'()*+,-bEqcFrdstG./nopuH:IJvwKx

443

444 return _init_cufile() (empty)

445

446

447cpdef dict _inspect_function_pointers(): (empty)

448 global _cyb_func_ptrs

449 if _cyb_func_ptrs is not None:

450 return _cyb_func_ptrs

451

452 _check_or_init_cufile()

453 cdef dict data = {}

454 global __cuFileHandleRegister

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

456

457 global __cuFileHandleDeregister

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

459

460 global __cuFileBufRegister

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

462

463 global __cuFileBufDeregister

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

465

466 global __cuFileRead

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

468

469 global __cuFileWrite

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

471

472 global __cuFileDriverOpen

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

474

475 global __cuFileDriverClose

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

477

478 global __cuFileDriverClose_v2

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

480

481 global __cuFileUseCount

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

483

484 global __cuFileDriverGetProperties

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

486

487 global __cuFileDriverSetPollMode

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

489

490 global __cuFileDriverSetMaxDirectIOSize

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

492

493 global __cuFileDriverSetMaxCacheSize

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

495

496 global __cuFileDriverSetMaxPinnedMemSize

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

498

499 global __cuFileBatchIOSetUp

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

501

502 global __cuFileBatchIOSubmit

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

504

505 global __cuFileBatchIOGetStatus

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

507

508 global __cuFileBatchIOCancel

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

510

511 global __cuFileBatchIODestroy

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

513

514 global __cuFileReadAsync

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

516

517 global __cuFileWriteAsync

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

519

520 global __cuFileStreamRegister

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

522

523 global __cuFileStreamDeregister

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

525

526 global __cuFileGetVersion

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

528

529 global __cuFileGetParameterSizeT

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

531

532 global __cuFileGetParameterBool

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

534

535 global __cuFileGetParameterString

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

537

538 global __cuFileSetParameterSizeT

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

540

541 global __cuFileSetParameterBool

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

543

544 global __cuFileSetParameterString

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

546

547 global __cuFileGetParameterMinMaxValue

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

549

550 global __cuFileSetStatsLevel

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

552

553 global __cuFileGetStatsLevel

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

555

556 global __cuFileStatsStart

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

558

559 global __cuFileStatsStop

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

561

562 global __cuFileStatsReset

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

564

565 global __cuFileGetStatsL1

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

567

568 global __cuFileGetStatsL2

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

570

571 global __cuFileGetStatsL3

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

573

574 global __cuFileGetBARSizeInKB

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

576

577 global __cuFileSetParameterPosixPoolSlabArray

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

579

580 global __cuFileGetParameterPosixPoolSlabArray

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

582

583 global __cuFileReadv

584 data["__cuFileReadv"] = <intptr_t>__cuFileReadv

585

586 global __cuFileWritev

587 data["__cuFileWritev"] = <intptr_t>__cuFileWritev

588 _cyb_func_ptrs = data

589 return data

590

591

592cpdef _inspect_function_pointer(str name): (empty)

593 global _cyb_func_ptrs

594 if _cyb_func_ptrs is None:

595 _cyb_func_ptrs = _inspect_function_pointers()

596 return _cyb_func_ptrs[name]

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

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

603 return <void*>handle (empty)

604

605

606###############################################################################

607# Wrapper functions

608

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

610 global __cuFileHandleRegister

611 _check_or_init_cufile() 13 ctx1efghiklmjbcdG

612 if __cuFileHandleRegister == NULL: 13 ctx1efghiklmjbcdG

613 with gil:

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

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

616 fh, descr)

617

618

619@_cyb_cython.show_performance_hints(False) (empty)

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

621 global __cuFileHandleDeregister

622 _check_or_init_cufile() 13 ctx1efghiklmjbcdG

623 if __cuFileHandleDeregister == NULL: 13 ctx1efghiklmjbcdG

624 with gil:

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

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

627 fh)

628

629

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

631 global __cuFileBufRegister

632 _check_or_init_cufile() 18 ctx1efgyzABCDhiklmjbcd

633 if __cuFileBufRegister == NULL: 18 ctx1efgyzABCDhiklmjbcd

634 with gil:

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

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

637 bufPtr_base, length, flags)

638

639

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

641 global __cuFileBufDeregister

642 _check_or_init_cufile() 18 ctx1efgyzABCDhiklmjbcd

643 if __cuFileBufDeregister == NULL: 18 ctx1efgyzABCDhiklmjbcd

644 with gil:

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

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

647 bufPtr_base)

648

649

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

651 global __cuFileRead

652 _check_or_init_cufile() 6 ctx1klmbcd

653 if __cuFileRead == NULL: 6 ctx1klmbcd

654 with gil:

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

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

657 fh, bufPtr_base, size, file_offset, bufPtr_offset)

658

659

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

661 global __cuFileWrite

662 _check_or_init_cufile() 6 ctx1klmbcd

663 if __cuFileWrite == NULL: 6 ctx1klmbcd

664 with gil:

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

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

667 fh, bufPtr_base, size, file_offset, bufPtr_offset)

668

669

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

671 global __cuFileDriverOpen

672 _check_or_init_cufile() 28 ctx1LNPRTVXZ13579#%),EFs.nopuHJK

673 if __cuFileDriverOpen == NULL: 28 ctx1LNPRTVXZ13579#%),EFs.nopuHJK

674 with gil:

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

676 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverOpen)( 28 ctx1LNPRTVXZ13579#%),EFs.nopuHJK

677 )

678

679

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

681 global __cuFileDriverClose

682 _check_or_init_cufile()

683 if __cuFileDriverClose == NULL:

684 with gil:

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

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

687 )

688

689

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

691 global __cuFileDriverClose_v2

692 _check_or_init_cufile() 29 ctx1MOQSUWY02468!$'*-qrst/nopu:vx

693 if __cuFileDriverClose_v2 == NULL: 29 ctx1MOQSUWY02468!$'*-qrst/nopu:vx

694 with gil:

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

696 return (<CUfileError_t (*)() noexcept nogil>__cuFileDriverClose_v2)( 29 ctx1MOQSUWY02468!$'*-qrst/nopu:vx

697 )

698

699

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

701 global __cuFileUseCount

702 _check_or_init_cufile()

703 if __cuFileUseCount == NULL:

704 with gil:

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

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

707 )

708

709

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

711 global __cuFileDriverGetProperties

712 _check_or_init_cufile()

713 if __cuFileDriverGetProperties == NULL:

714 with gil:

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

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

717 props)

718

719

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

721 global __cuFileDriverSetPollMode

722 _check_or_init_cufile()

723 if __cuFileDriverSetPollMode == NULL:

724 with gil:

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

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

727 poll, poll_threshold_size)

728

729

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

731 global __cuFileDriverSetMaxDirectIOSize

732 _check_or_init_cufile()

733 if __cuFileDriverSetMaxDirectIOSize == NULL:

734 with gil:

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

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

737 max_direct_io_size)

738

739

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

741 global __cuFileDriverSetMaxCacheSize

742 _check_or_init_cufile()

743 if __cuFileDriverSetMaxCacheSize == NULL:

744 with gil:

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

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

747 max_cache_size)

748

749

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

751 global __cuFileDriverSetMaxPinnedMemSize

752 _check_or_init_cufile()

753 if __cuFileDriverSetMaxPinnedMemSize == NULL:

754 with gil:

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

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

757 max_pinned_size)

758

759

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

761 global __cuFileBatchIOSetUp

762 _check_or_init_cufile() 3 ctx1efg

763 if __cuFileBatchIOSetUp == NULL: 3 ctx1efg

764 with gil:

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

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

767 batch_idp, nr)

768

769

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

771 global __cuFileBatchIOSubmit

772 _check_or_init_cufile() 3 ctx1efg

773 if __cuFileBatchIOSubmit == NULL: 3 ctx1efg

774 with gil:

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

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

777 batch_idp, nr, iocbp, flags)

778

779

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

781 global __cuFileBatchIOGetStatus

782 _check_or_init_cufile() 2 ctx1eg

783 if __cuFileBatchIOGetStatus == NULL: 2 ctx1eg

784 with gil:

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

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

787 batch_idp, min_nr, nr, iocbp, timeout)

788

789

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

791 global __cuFileBatchIOCancel

792 _check_or_init_cufile() 1 ctx1f

793 if __cuFileBatchIOCancel == NULL: 1 ctx1f

794 with gil:

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

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

797 batch_idp)

798

799

800@_cyb_cython.show_performance_hints(False) (empty)

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

802 global __cuFileBatchIODestroy

803 _check_or_init_cufile() 3 ctx1efg

804 if __cuFileBatchIODestroy == NULL: 3 ctx1efg

805 with gil:

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

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

808 batch_idp)

809

810

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

812 global __cuFileReadAsync

813 _check_or_init_cufile() 2 ctx1hi

814 if __cuFileReadAsync == NULL: 2 ctx1hi

815 with gil:

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

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

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

819

820

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

822 global __cuFileWriteAsync

823 _check_or_init_cufile() 2 ctx1hj

824 if __cuFileWriteAsync == NULL: 2 ctx1hj

825 with gil:

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

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

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

829

830

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

832 global __cuFileStreamRegister

833 _check_or_init_cufile() 3 ctx1hij

834 if __cuFileStreamRegister == NULL: 3 ctx1hij

835 with gil:

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

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

838 stream, flags)

839

840

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

842 global __cuFileStreamDeregister

843 _check_or_init_cufile() 3 ctx1hij

844 if __cuFileStreamDeregister == NULL: 3 ctx1hij

845 with gil:

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

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

848 stream)

849

850

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

852 global __cuFileGetVersion

853 _check_or_init_cufile() 2 ctx1an

854 if __cuFileGetVersion == NULL: 2 ctx1an

855 with gil:

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

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

858 version)

859

860

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

862 global __cuFileGetParameterSizeT

863 _check_or_init_cufile() 1 ctx1o

864 if __cuFileGetParameterSizeT == NULL: 1 ctx1o

865 with gil:

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

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

868 param, value)

869

870

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

872 global __cuFileGetParameterBool

873 _check_or_init_cufile() 1 ctx1n

874 if __cuFileGetParameterBool == NULL: 1 ctx1n

875 with gil:

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

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

878 param, value)

879

880

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

882 global __cuFileGetParameterString

883 _check_or_init_cufile() 1 ctx1p

884 if __cuFileGetParameterString == NULL: 1 ctx1p

885 with gil:

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

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

888 param, desc_str, len)

889

890

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

892 global __cuFileSetParameterSizeT

893 _check_or_init_cufile() 1 ctx1o

894 if __cuFileSetParameterSizeT == NULL: 1 ctx1o

895 with gil:

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

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

898 param, value)

899

900

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

902 global __cuFileSetParameterBool

903 _check_or_init_cufile() 1 ctx1n

904 if __cuFileSetParameterBool == NULL: 1 ctx1n

905 with gil:

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

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

908 param, value)

909

910

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

912 global __cuFileSetParameterString

913 _check_or_init_cufile() 1 ctx1p

914 if __cuFileSetParameterString == NULL: 1 ctx1p

915 with gil:

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

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

918 param, desc_str)

919

920

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

922 global __cuFileGetParameterMinMaxValue

923 _check_or_init_cufile() 1 ctx1+

924 if __cuFileGetParameterMinMaxValue == NULL: 1 ctx1+

925 with gil:

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

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

928 param, min_value, max_value)

929

930

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

932 global __cuFileSetStatsLevel

933 _check_or_init_cufile() 10 ctx1bqcrdtIvwx

934 if __cuFileSetStatsLevel == NULL: 10 ctx1bqcrdtIvwx

935 with gil:

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

937 return (<CUfileError_t (*)(int) noexcept nogil>__cuFileSetStatsLevel)( 10 ctx1bqcrdtIvwx

938 level)

939

940

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

942 global __cuFileGetStatsLevel

943 _check_or_init_cufile() 6 ctx1EFsIJK

944 if __cuFileGetStatsLevel == NULL: 6 ctx1EFsIJK

945 with gil:

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

947 return (<CUfileError_t (*)(int*) noexcept nogil>__cuFileGetStatsLevel)( 6 ctx1EFsIJK

948 level)

949

950

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

952 global __cuFileStatsStart

953 _check_or_init_cufile() 4 ctx1bcdw

954 if __cuFileStatsStart == NULL: 4 ctx1bcdw

955 with gil:

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

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

958 )

959

960

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

962 global __cuFileStatsStop

963 _check_or_init_cufile() 4 ctx1bcdw

964 if __cuFileStatsStop == NULL: 4 ctx1bcdw

965 with gil:

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

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

968 )

969

970

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

972 global __cuFileStatsReset

973 _check_or_init_cufile() 5 ctx1qrtvx

974 if __cuFileStatsReset == NULL: 5 ctx1qrtvx

975 with gil:

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

977 return (<CUfileError_t (*)() noexcept nogil>__cuFileStatsReset)( 5 ctx1qrtvx

978 )

979

980

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

982 global __cuFileGetStatsL1

983 _check_or_init_cufile() 1 ctx1b

984 if __cuFileGetStatsL1 == NULL: 1 ctx1b

985 with gil:

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

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

988 stats)

989

990

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

992 global __cuFileGetStatsL2

993 _check_or_init_cufile() 1 ctx1c

994 if __cuFileGetStatsL2 == NULL: 1 ctx1c

995 with gil:

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

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

998 stats)

999

1000

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

1002 global __cuFileGetStatsL3

1003 _check_or_init_cufile() 1 ctx1d

1004 if __cuFileGetStatsL3 == NULL: 1 ctx1d

1005 with gil:

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

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

1008 stats)

1009

1010

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

1012 global __cuFileGetBARSizeInKB

1013 _check_or_init_cufile() 1 ctx1(

1014 if __cuFileGetBARSizeInKB == NULL: 1 ctx1(

1015 with gil:

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

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

1018 gpuIndex, barSize)

1019

1020

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

1022 global __cuFileSetParameterPosixPoolSlabArray

1023 _check_or_init_cufile() 1 ctx1H

1024 if __cuFileSetParameterPosixPoolSlabArray == NULL: 1 ctx1H

1025 with gil:

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

1027 return (<CUfileError_t (*)(const size_t*, const size_t*, int) noexcept nogil>__cuFileSetParameterPosixPoolSlabArray)( 1 ctx1H

1028 size_values, count_values, len)

1029

1030

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

1032 global __cuFileGetParameterPosixPoolSlabArray

1033 _check_or_init_cufile() 1 ctx1u

1034 if __cuFileGetParameterPosixPoolSlabArray == NULL: 1 ctx1u

1035 with gil:

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

1037 return (<CUfileError_t (*)(size_t*, size_t*, int) noexcept nogil>__cuFileGetParameterPosixPoolSlabArray)( 1 ctx1u

1038 size_values, count_values, len)

1039

1040

1041cdef ssize_t _cuFileReadv(CUfileHandle_t fh, const CUfileIOVec_t* iov, size_t iovcnt, off_t file_offset, unsigned flags) except* nogil: (empty)

1042 global __cuFileReadv

1043 _check_or_init_cufile()

1044 if __cuFileReadv == NULL:

1045 with gil:

1046 raise FunctionNotFoundError("function cuFileReadv is not found")

1047 return (<ssize_t (*)(CUfileHandle_t, const CUfileIOVec_t*, size_t, off_t, unsigned) noexcept nogil>__cuFileReadv)(

1048 fh, iov, iovcnt, file_offset, flags)

1049

1050

1051cdef ssize_t _cuFileWritev(CUfileHandle_t fh, const CUfileIOVec_t* iov, size_t iovcnt, off_t file_offset, unsigned flags) except* nogil: (empty)

1052 global __cuFileWritev

1053 _check_or_init_cufile()

1054 if __cuFileWritev == NULL:

1055 with gil:

1056 raise FunctionNotFoundError("function cuFileWritev is not found")

1057 return (<ssize_t (*)(CUfileHandle_t, const CUfileIOVec_t*, size_t, off_t, unsigned) noexcept nogil>__cuFileWritev)(

1058 fh, iov, iovcnt, file_offset, flags)