Coverage for cuda/bindings/_internal/nvfatbin.pyx: 67.38%

1# SPDX-FileCopyrightText: Copyright (c) 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.4.1 to 13.3.0. Do not modify it directly. 

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

7  

8  

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

10  

11cdef extern from * nogil: 

12 """ 

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

14 #include <intrin.h> 

15 static __forceinline int atomic_int_load(int *p) { 

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

17 } 

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

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

20 } 

21 #elif defined(__cplusplus) 

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

23 static inline int atomic_int_load(int *p) { 

24 return __atomic_load_n(p, __ATOMIC_ACQUIRE); 

25 } 

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

27 __atomic_store_n(p, v, __ATOMIC_RELEASE); 

28 } 

29 #else 

30 #include <stdatomic.h> 

31 static inline int atomic_int_load(int *p) { 

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

33 } 

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

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

36 } 

37 #endif 

38  

39 """ 

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

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

42  

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

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

45 const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" 

46  

47from libc.stdint cimport intptr_t 

48  

49import threading as _cyb_threading (empty)

50  

51cdef int _cyb___py_nvfatbin_init = 0 (empty)

52cdef dict _cyb_func_ptrs = None (empty)

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

54  

55# <<<< END OF PREAMBLE CONTENT >>>> 

56  

57from libc.stdint cimport uintptr_t 

58  

59from .utils import FunctionNotFoundError, NotSupportedError (empty)

60from cuda.pathfinder import load_nvidia_dynamic_lib (empty)

61  

62  

63############################################################################### 

64# Wrapper init 

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

66  

67cdef void* __nvFatbinGetErrorString = NULL (empty)

68cdef void* __nvFatbinCreate = NULL (empty)

69cdef void* __nvFatbinDestroy = NULL (empty)

70cdef void* __nvFatbinAddPTX = NULL (empty)

71cdef void* __nvFatbinAddCubin = NULL (empty)

72cdef void* __nvFatbinAddLTOIR = NULL (empty)

73cdef void* __nvFatbinSize = NULL (empty)

74cdef void* __nvFatbinGet = NULL (empty)

75cdef void* __nvFatbinVersion = NULL (empty)

76cdef void* __nvFatbinAddIndex = NULL (empty)

77cdef void* __nvFatbinAddReloc = NULL (empty)

78cdef void* __nvFatbinAddTileIR = NULL (empty)

79  

80cdef int _init_nvfatbin() except -1 nogil: (empty)

81 global _cyb___py_nvfatbin_init 

82 cdef void* handle = NULL (empty)

83 with gil, _cyb_symbol_lock: (empty)

84 if _cyb___py_nvfatbin_init: return 0 (empty)

85  

86 global __nvFatbinGetErrorString 

87 __nvFatbinGetErrorString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinGetErrorString') (empty)

88 if __nvFatbinGetErrorString == NULL: (empty)

89 if handle == NULL: (empty)

90 handle = load_library() (empty)

91 __nvFatbinGetErrorString = _cyb_dlsym(handle, 'nvFatbinGetErrorString') (empty)

92  

93 global __nvFatbinCreate 

94 __nvFatbinCreate = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinCreate') (empty)

95 if __nvFatbinCreate == NULL: (empty)

96 if handle == NULL: (empty)

97 handle = load_library() 

98 __nvFatbinCreate = _cyb_dlsym(handle, 'nvFatbinCreate') 

99  

100 global __nvFatbinDestroy 

101 __nvFatbinDestroy = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinDestroy') (empty)

102 if __nvFatbinDestroy == NULL: (empty)

103 if handle == NULL: 

104 handle = load_library() 

105 __nvFatbinDestroy = _cyb_dlsym(handle, 'nvFatbinDestroy') (empty)

106  

107 global __nvFatbinAddPTX 

108 __nvFatbinAddPTX = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddPTX') (empty)

109 if __nvFatbinAddPTX == NULL: (empty)

110 if handle == NULL: 

111 handle = load_library() (empty)

112 __nvFatbinAddPTX = _cyb_dlsym(handle, 'nvFatbinAddPTX') 

113  

114 global __nvFatbinAddCubin 

115 __nvFatbinAddCubin = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddCubin') (empty)

116 if __nvFatbinAddCubin == NULL: (empty)

117 if handle == NULL: (empty)

118 handle = load_library() 

119 __nvFatbinAddCubin = _cyb_dlsym(handle, 'nvFatbinAddCubin') 

120  

121 global __nvFatbinAddLTOIR 

122 __nvFatbinAddLTOIR = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddLTOIR') (empty)

123 if __nvFatbinAddLTOIR == NULL: (empty)

124 if handle == NULL: 

125 handle = load_library() (empty)

126 __nvFatbinAddLTOIR = _cyb_dlsym(handle, 'nvFatbinAddLTOIR') (empty)

127  

128 global __nvFatbinSize 

129 __nvFatbinSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinSize') 102 ctx2a - . / : ; = ? @ [ ] ^ _ ` { | } ~ abe f g h m n o p $ % q r s t u v w x y z A B C D E F G ) 2 + tbb c d bbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbi j k l H I J K ' ( L M N O P Q R S T U V W X Y Z 0 1 * 3 , ub

130 if __nvFatbinSize == NULL: 102 ctx2a - . / : ; = ? @ [ ] ^ _ ` { | } ~ abe f g h m n o p $ % q r s t u v w x y z A B C D E F G ) 2 + tbb c d bbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbi j k l H I J K ' ( L M N O P Q R S T U V W X Y Z 0 1 * 3 , ub

131 if handle == NULL: 

132 handle = load_library() (empty)

133 __nvFatbinSize = _cyb_dlsym(handle, 'nvFatbinSize') 

134  

135 global __nvFatbinGet 

136 __nvFatbinGet = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinGet') (empty)

137 if __nvFatbinGet == NULL: (empty)

138 if handle == NULL: 

139 handle = load_library() 

140 __nvFatbinGet = _cyb_dlsym(handle, 'nvFatbinGet') 

141  

142 global __nvFatbinVersion 

143 __nvFatbinVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinVersion') (empty)

144 if __nvFatbinVersion == NULL: (empty)

145 if handle == NULL: 

146 handle = load_library() 

147 __nvFatbinVersion = _cyb_dlsym(handle, 'nvFatbinVersion') 

148  

149 global __nvFatbinAddIndex 

150 __nvFatbinAddIndex = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddIndex') (empty)

151 if __nvFatbinAddIndex == NULL: (empty)

152 if handle == NULL: 

153 handle = load_library() 

154 __nvFatbinAddIndex = _cyb_dlsym(handle, 'nvFatbinAddIndex') 

155  

156 global __nvFatbinAddReloc 

157 __nvFatbinAddReloc = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddReloc') (empty)

158 if __nvFatbinAddReloc == NULL: (empty)

159 if handle == NULL: 

160 handle = load_library() 

161 __nvFatbinAddReloc = _cyb_dlsym(handle, 'nvFatbinAddReloc') 

162  

163 global __nvFatbinAddTileIR 

164 __nvFatbinAddTileIR = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinAddTileIR') (empty)

165 if __nvFatbinAddTileIR == NULL: (empty)

166 if handle == NULL: 

167 handle = load_library() 

168 __nvFatbinAddTileIR = _cyb_dlsym(handle, 'nvFatbinAddTileIR') 

169  

170 _cyb_atomic_int_store(<int *>&_cyb___py_nvfatbin_init, 1) (empty)

171 return 0 (empty)

172  

173cdef inline int _check_or_init_nvfatbin() except -1 nogil: (empty)

174 if _cyb_atomic_int_load(<int *>&_cyb___py_nvfatbin_init): 110 ctx2a - . / : ; = ? @ [ ] ^ _ ` { | } ~ abe f g h m n o p $ % q r s t u v w x y z A B C D E F 4 5 6 7 G ) 2 + tbb c d bbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbi j k l H I J K ' ( L M N O P Q R S T U V W X Y Z 0 8 9 ! # 1 * 3 , ub

175 return 0 110 ctx2a - . / : ; = ? @ [ ] ^ _ ` { | } ~ abe f g h m n o p $ % q r s t u v w x y z A B C D E F 4 5 6 7 G ) 2 + tbb c d bbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbi j k l H I J K ' ( L M N O P Q R S T U V W X Y Z 0 8 9 ! # 1 * 3 , ub

176  

177 return _init_nvfatbin() (empty)

178  

179  

180cpdef dict _inspect_function_pointers(): (empty)

181 global _cyb_func_ptrs 

182 if _cyb_func_ptrs is not None: 

183 return _cyb_func_ptrs 

184  

185 _check_or_init_nvfatbin() 

186 cdef dict data = {} 

187 global __nvFatbinGetErrorString 

188 data["__nvFatbinGetErrorString"] = <intptr_t>__nvFatbinGetErrorString 

189  

190 global __nvFatbinCreate 

191 data["__nvFatbinCreate"] = <intptr_t>__nvFatbinCreate (empty)

192  

193 global __nvFatbinDestroy 

194 data["__nvFatbinDestroy"] = <intptr_t>__nvFatbinDestroy 

195  

196 global __nvFatbinAddPTX 

197 data["__nvFatbinAddPTX"] = <intptr_t>__nvFatbinAddPTX 

198  

199 global __nvFatbinAddCubin 

200 data["__nvFatbinAddCubin"] = <intptr_t>__nvFatbinAddCubin 36 ctx2- . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsb

201  

202 global __nvFatbinAddLTOIR 

203 data["__nvFatbinAddLTOIR"] = <intptr_t>__nvFatbinAddLTOIR 

204  

205 global __nvFatbinSize 

206 data["__nvFatbinSize"] = <intptr_t>__nvFatbinSize 

207  

208 global __nvFatbinGet 

209 data["__nvFatbinGet"] = <intptr_t>__nvFatbinGet 

210  

211 global __nvFatbinVersion 

212 data["__nvFatbinVersion"] = <intptr_t>__nvFatbinVersion 

213  

214 global __nvFatbinAddIndex 

215 data["__nvFatbinAddIndex"] = <intptr_t>__nvFatbinAddIndex 

216  

217 global __nvFatbinAddReloc 

218 data["__nvFatbinAddReloc"] = <intptr_t>__nvFatbinAddReloc (empty)

219  

220 global __nvFatbinAddTileIR 

221 data["__nvFatbinAddTileIR"] = <intptr_t>__nvFatbinAddTileIR 61 ctx1efghmnop$%qrstuvwxyzABCDEFG)2bcdijklHIJK'(LMNOPQRSTUVWXYZ01*3

222 _cyb_func_ptrs = data 

223 return data 

224  

225  

226cpdef _inspect_function_pointer(str name): (empty)

227 global _cyb_func_ptrs 

228 if _cyb_func_ptrs is None: (empty)

229 _cyb_func_ptrs = _inspect_function_pointers() 

230 return _cyb_func_ptrs[name] 35 ctx1qrstuvwxyzABCDEFbcdLMNOPQRSTUVWXYZ0

231  

232  

233  

234  

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

236 cdef uintptr_t handle = load_nvidia_dynamic_lib("nvfatbin")._handle_uint (empty)

237 return <void*>handle (empty)

238  

239  

240############################################################################### 

241# Wrapper functions 

242############################################################################### 

243  

244cdef const char* _nvFatbinGetErrorString(nvFatbinResult result) except?NULL nogil: 16 ctx1amnop$%bcdHIJK'(

245 global __nvFatbinGetErrorString 

246 _check_or_init_nvfatbin() 36 ctx2- . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsb

247 if __nvFatbinGetErrorString == NULL: 36 ctx2- . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsb

248 with gil: (empty)

249 raise FunctionNotFoundError("function nvFatbinGetErrorString is not found") 

250 return (<const char* (*)(nvFatbinResult) noexcept nogil>__nvFatbinGetErrorString)( 44 ctx2- . / : ; = ? @ [ ] ^ _ ` { | } ~ abe f g h bbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbi j k l

251 result) 

252  

253  

254cdef nvFatbinResult _nvFatbinCreate(nvFatbinHandle* handle_indirect, const char** options, size_t optionsCount) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: 9 ctx1aefghijkl

255 global __nvFatbinCreate 

256 _check_or_init_nvfatbin() 71 ctx2e f g h m n o p $ % q r s t u v w x y z A B C D E F 4 5 6 7 G ) 2 tbb c d i j k l H I J K ' ( L M N O P Q R S T U V W X Y Z 0 8 9 ! # 1 * 3 ub

257 if __nvFatbinCreate == NULL: 71 ctx2e f g h m n o p $ % q r s t u v w x y z A B C D E F 4 5 6 7 G ) 2 tbb c d i j k l H I J K ' ( L M N O P Q R S T U V W X Y Z 0 8 9 ! # 1 * 3 ub

258 with gil: (empty)

259 raise FunctionNotFoundError("function nvFatbinCreate is not found") 

260 return (<nvFatbinResult (*)(nvFatbinHandle*, const char**, size_t) noexcept nogil>__nvFatbinCreate)( 71 ctx2e f g h m n o p $ % q r s t u v w x y z A B C D E F 4 5 6 7 G ) 2 tbb c d i j k l H I J K ' ( L M N O P Q R S T U V W X Y Z 0 8 9 ! # 1 * 3 ub

261 handle_indirect, options, optionsCount) 

262  

263  

264cdef nvFatbinResult _nvFatbinDestroy(nvFatbinHandle* handle_indirect) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: 56 ctx1aefghmnopqrstuvwxyzABCDEFG2bcdijklHIJKLMNOPQRSTUVWXYZ013

265 global __nvFatbinDestroy 

266 _check_or_init_nvfatbin() 69 ctx1efghmnop$%qrstuvwxyzABCDEF4567G)2bcdijklHIJK'(LMNOPQRSTUVWXYZ089!#1*3

267 if __nvFatbinDestroy == NULL: 69 ctx1efghmnop$%qrstuvwxyzABCDEF4567G)2bcdijklHIJK'(LMNOPQRSTUVWXYZ089!#1*3

268 with gil: (empty)

269 raise FunctionNotFoundError("function nvFatbinDestroy is not found") 

270 return (<nvFatbinResult (*)(nvFatbinHandle*) noexcept nogil>__nvFatbinDestroy)( 69 ctx1efghmnop$%qrstuvwxyzABCDEF4567G)2bcdijklHIJK'(LMNOPQRSTUVWXYZ089!#1*3

271 handle_indirect) 

272  

273  

274cdef nvFatbinResult _nvFatbinAddPTX(nvFatbinHandle handle, const char* code, size_t size, const char* arch, const char* identifier, const char* optionsCmdLine) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: 56 ctx1aefghmnopqrstuvwxyzABCDEFG2bcdijklHIJKLMNOPQRSTUVWXYZ013

275 global __nvFatbinAddPTX 

276 _check_or_init_nvfatbin() 35 ctx1qrstuvwxyzABCDEFbcdLMNOPQRSTUVWXYZ0

277 if __nvFatbinAddPTX == NULL: 35 ctx1qrstuvwxyzABCDEFbcdLMNOPQRSTUVWXYZ0

278 with gil: (empty)

279 raise FunctionNotFoundError("function nvFatbinAddPTX is not found") 

280 return (<nvFatbinResult (*)(nvFatbinHandle, const char*, size_t, const char*, const char*, const char*) noexcept nogil>__nvFatbinAddPTX)( 38 ctx1aqrstuvwxyzABCDEF+bcdLMNOPQRSTUVWXYZ0,

281 handle, code, size, arch, identifier, optionsCmdLine) 

282  

283  

284cdef nvFatbinResult _nvFatbinAddCubin(nvFatbinHandle handle, const void* code, size_t size, const char* arch, const char* identifier) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: 3 ctx1a+,

285 global __nvFatbinAddCubin 

286 _check_or_init_nvfatbin() 15 ctx1mnop$%bcdHIJK'(

287 if __nvFatbinAddCubin == NULL: 15 ctx1mnop$%bcdHIJK'(

288 with gil: (empty)

289 raise FunctionNotFoundError("function nvFatbinAddCubin is not found") 

290 return (<nvFatbinResult (*)(nvFatbinHandle, const void*, size_t, const char*, const char*) noexcept nogil>__nvFatbinAddCubin)( 15 ctx1mnop$%bcdHIJK'(

291 handle, code, size, arch, identifier) 

292  

293  

294cdef nvFatbinResult _nvFatbinAddLTOIR(nvFatbinHandle handle, const void* code, size_t size, const char* arch, const char* identifier, const char* optionsCmdLine) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

295 global __nvFatbinAddLTOIR 

296 _check_or_init_nvfatbin() 8 ctx1efghijkl

297 if __nvFatbinAddLTOIR == NULL: 8 ctx1efghijkl

298 with gil: (empty)

299 raise FunctionNotFoundError("function nvFatbinAddLTOIR is not found") 

300 return (<nvFatbinResult (*)(nvFatbinHandle, const void*, size_t, const char*, const char*, const char*) noexcept nogil>__nvFatbinAddLTOIR)( 8 ctx1efghijkl

301 handle, code, size, arch, identifier, optionsCmdLine) 

302  

303  

304cdef nvFatbinResult _nvFatbinSize(nvFatbinHandle handle, size_t* size) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

305 global __nvFatbinSize 

306 _check_or_init_nvfatbin() 63 ctx1efghmnopqrstuvwxyzABCDEF4567G2bcdijklHIJKLMNOPQRSTUVWXYZ089!#13

307 if __nvFatbinSize == NULL: 63 ctx1efghmnopqrstuvwxyzABCDEF4567G2bcdijklHIJKLMNOPQRSTUVWXYZ089!#13

308 with gil: (empty)

309 raise FunctionNotFoundError("function nvFatbinSize is not found") 

310 return (<nvFatbinResult (*)(nvFatbinHandle, size_t*) noexcept nogil>__nvFatbinSize)( 63 ctx1efghmnopqrstuvwxyzABCDEF4567G2bcdijklHIJKLMNOPQRSTUVWXYZ089!#13

311 handle, size) 

312  

313  

314cdef nvFatbinResult _nvFatbinGet(nvFatbinHandle handle, void* buffer) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: 3 ctx1aG1

315 global __nvFatbinGet 

316 _check_or_init_nvfatbin() 63 ctx1efghmnopqrstuvwxyzABCDEF4567G2bcdijklHIJKLMNOPQRSTUVWXYZ089!#13

317 if __nvFatbinGet == NULL: 63 ctx1efghmnopqrstuvwxyzABCDEF4567G2bcdijklHIJKLMNOPQRSTUVWXYZ089!#13

318 with gil: 

319 raise FunctionNotFoundError("function nvFatbinGet is not found") 

320 return (<nvFatbinResult (*)(nvFatbinHandle, void*) noexcept nogil>__nvFatbinGet)( 63 ctx1efghmnopqrstuvwxyzABCDEF4567G2bcdijklHIJKLMNOPQRSTUVWXYZ089!#13

321 handle, buffer) 

322  

323  

324cdef nvFatbinResult _nvFatbinVersion(unsigned int* major, unsigned int* minor) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

325 global __nvFatbinVersion 

326 _check_or_init_nvfatbin() 3 ctx1a+,

327 if __nvFatbinVersion == NULL: 3 ctx1a+,

328 with gil: 

329 raise FunctionNotFoundError("function nvFatbinVersion is not found") 

330 return (<nvFatbinResult (*)(unsigned int*, unsigned int*) noexcept nogil>__nvFatbinVersion)( 3 ctx1a+,

331 major, minor) 

332  

333  

334cdef nvFatbinResult _nvFatbinAddIndex(nvFatbinHandle handle, const void* code, size_t size, const char* identifier) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

335 global __nvFatbinAddIndex 

336 _check_or_init_nvfatbin() 

337 if __nvFatbinAddIndex == NULL: 

338 with gil: 

339 raise FunctionNotFoundError("function nvFatbinAddIndex is not found") 

340 return (<nvFatbinResult (*)(nvFatbinHandle, const void*, size_t, const char*) noexcept nogil>__nvFatbinAddIndex)( 

341 handle, code, size, identifier) 

342  

343  

344cdef nvFatbinResult _nvFatbinAddReloc(nvFatbinHandle handle, const void* code, size_t size) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

345 global __nvFatbinAddReloc 

346 _check_or_init_nvfatbin() 8 ctx1456789!#

347 if __nvFatbinAddReloc == NULL: 8 ctx1456789!#

348 with gil: 

349 raise FunctionNotFoundError("function nvFatbinAddReloc is not found") 

350 return (<nvFatbinResult (*)(nvFatbinHandle, const void*, size_t) noexcept nogil>__nvFatbinAddReloc)( 8 ctx1456789!#

351 handle, code, size) 

352  

353  

354cdef nvFatbinResult _nvFatbinAddTileIR(nvFatbinHandle handle, const void* code, size_t size, const char* identifier, const char* optionsCmdLine) except?_NVFATBINRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

355 global __nvFatbinAddTileIR 

356 _check_or_init_nvfatbin() 2 ctx1G1

357 if __nvFatbinAddTileIR == NULL: 2 ctx1G1

358 with gil: 

359 raise FunctionNotFoundError("function nvFatbinAddTileIR is not found") 

360 return (<nvFatbinResult (*)(nvFatbinHandle, const void*, size_t, const char*, const char*) noexcept nogil>__nvFatbinAddTileIR)( 2 ctx1G1

361 handle, code, size, identifier, optionsCmdLine)