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

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

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 as _cyb_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') 99 ctx2a - . / : ; = ? @ [ ] ^ _ ` { | } ~ abb c d e j k l m $ % n o p q r s t u v w x y z A B C D ) 2 + tbbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbf g h i E F G H ' ( I J K L M N O P Q R S T U V W X Y * 3 , ub

127  

128 global __nvFatbinSize 

129 __nvFatbinSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvFatbinSize') (empty)

130 if __nvFatbinSize == NULL: (empty)

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

175 return 0 110 ctx2a - . / : ; = ? @ [ ] ^ _ ` { | } ~ abb c d e j k l m $ % n o p q r s t u v w x y z A B C 4 5 6 7 D ) 2 + tbZ 0 1 bbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbf g h i E F G H ' ( I J K L M N O P Q R S T U V W X 8 9 ! # Y * 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"] = <_cyb_intptr_t>__nvFatbinGetErrorString (empty)

189  

190 global __nvFatbinCreate 

191 data["__nvFatbinCreate"] = <_cyb_intptr_t>__nvFatbinCreate 

192  

193 global __nvFatbinDestroy 

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

195  

196 global __nvFatbinAddPTX 

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

198  

199 global __nvFatbinAddCubin 

200 data["__nvFatbinAddCubin"] = <_cyb_intptr_t>__nvFatbinAddCubin 

201  

202 global __nvFatbinAddLTOIR 

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

204  

205 global __nvFatbinSize 

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

207  

208 global __nvFatbinGet 

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

210  

211 global __nvFatbinVersion 

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

213  

214 global __nvFatbinAddIndex 

215 data["__nvFatbinAddIndex"] = <_cyb_intptr_t>__nvFatbinAddIndex (empty)

216  

217 global __nvFatbinAddReloc 

218 data["__nvFatbinAddReloc"] = <_cyb_intptr_t>__nvFatbinAddReloc 58 ctx1bcdejklm$%nopqrstuvwxyzABCD)2fghiEFGH'(IJKLMNOPQRSTUVWXY*3

219  

220 global __nvFatbinAddTileIR 

221 data["__nvFatbinAddTileIR"] = <_cyb_intptr_t>__nvFatbinAddTileIR 58 ctx1bcdejklm$%nopqrstuvwxyzABCD)2fghiEFGH'(IJKLMNOPQRSTUVWXY*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: 32 ctx1nopqrstuvwxyzABCIJKLMNOPQRSTUVWX

229 _cyb_func_ptrs = _inspect_function_pointers() 

230 return _cyb_func_ptrs[name] 

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 13 ctx1ajklm$%EFGH'(

238  

239  

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

241# Wrapper functions 

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

243  

244cdef const char* _nvFatbinGetErrorString(nvFatbinResult result) except?NULL nogil: (empty)

245 global __nvFatbinGetErrorString 

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

247 if __nvFatbinGetErrorString == NULL: 44 ctx2- . / : ; = ? @ [ ] ^ _ ` { | } ~ abb c d e bbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbf g h i

248 with gil: 8 ctx1bcdefghi

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

250 return (<const char* (*)(nvFatbinResult) noexcept nogil>__nvFatbinGetErrorString)( 36 ctx2- . / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsb

251 result) 

252  

253  

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

255 global __nvFatbinCreate 

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

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

258 with gil: 52 ctx1bcdejklmnopqrstuvwxyzABCD2fghiEFGHIJKLMNOPQRSTUVWXY3

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

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

261 handle_indirect, options, optionsCount) 

262  

263  

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

265 global __nvFatbinDestroy 

266 _check_or_init_nvfatbin() 69 ctx1bcdejklm$%nopqrstuvwxyzABC4567D)2Z01fghiEFGH'(IJKLMNOPQRSTUVWX89!#Y*3

267 if __nvFatbinDestroy == NULL: 69 ctx1bcdejklm$%nopqrstuvwxyzABC4567D)2Z01fghiEFGH'(IJKLMNOPQRSTUVWX89!#Y*3

268 with gil: 52 ctx1bcdejklmnopqrstuvwxyzABCD2fghiEFGHIJKLMNOPQRSTUVWXY3

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

270 return (<nvFatbinResult (*)(nvFatbinHandle*) noexcept nogil>__nvFatbinDestroy)( 69 ctx1bcdejklm$%nopqrstuvwxyzABC4567D)2Z01fghiEFGH'(IJKLMNOPQRSTUVWX89!#Y*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: (empty)

275 global __nvFatbinAddPTX 

276 _check_or_init_nvfatbin() 35 ctx1nopqrstuvwxyzABCZ01IJKLMNOPQRSTUVWX

277 if __nvFatbinAddPTX == NULL: 38 ctx1anopqrstuvwxyzABC+Z01IJKLMNOPQRSTUVWX,

278 with gil: 3 ctx1a+,

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)( 35 ctx1nopqrstuvwxyzABCZ01IJKLMNOPQRSTUVWX

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: (empty)

285 global __nvFatbinAddCubin 

286 _check_or_init_nvfatbin() 15 ctx1jklm$%Z01EFGH'(

287 if __nvFatbinAddCubin == NULL: 15 ctx1jklm$%Z01EFGH'(

288 with gil: 

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

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

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 ctx1bcdefghi

297 if __nvFatbinAddLTOIR == NULL: 8 ctx1bcdefghi

298 with gil: 

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 ctx1bcdefghi

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 ctx1bcdejklmnopqrstuvwxyzABC4567D2Z01fghiEFGHIJKLMNOPQRSTUVWX89!#Y3

307 if __nvFatbinSize == NULL: 63 ctx1bcdejklmnopqrstuvwxyzABC4567D2Z01fghiEFGHIJKLMNOPQRSTUVWX89!#Y3

308 with gil: 2 ctx1DY

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

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

311 handle, size) 

312  

313  

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

315 global __nvFatbinGet 

316 _check_or_init_nvfatbin() 63 ctx1bcdejklmnopqrstuvwxyzABC4567D2Z01fghiEFGHIJKLMNOPQRSTUVWX89!#Y3

317 if __nvFatbinGet == NULL: 63 ctx1bcdejklmnopqrstuvwxyzABC4567D2Z01fghiEFGHIJKLMNOPQRSTUVWX89!#Y3

318 with gil: 

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

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

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 ctx1DY

357 if __nvFatbinAddTileIR == NULL: 2 ctx1DY

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 ctx1DY

361 handle, code, size, identifier, optionsCmdLine)