Coverage for cuda / bindings / _internal / nvvm.pyx: 63%

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.0.1 to 13.1.0. Do not modify it directly. 

6  

7from libc.stdint cimport intptr_t, uintptr_t 

8  

9import threading 

10from .utils import FunctionNotFoundError, NotSupportedError 

11  

12from cuda.pathfinder import load_nvidia_dynamic_lib 

13  

14  

15############################################################################### 

16# Extern 

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

18  

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

20  

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

22 void* dlopen(const char*, int) 

23 char* dlerror() 

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

25 int dlclose(void*) 

26  

27 enum: 

28 RTLD_LAZY 

29 RTLD_NOW 

30 RTLD_GLOBAL 

31 RTLD_LOCAL 

32  

33 const void* RTLD_DEFAULT 'RTLD_DEFAULT' 

34  

35cdef int get_cuda_version(): 

36 cdef void* handle = NULL 

37 cdef int err, driver_ver = 0 

38  

39 # Load driver to check version 

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

41 if handle == NULL: 

42 err_msg = dlerror() 

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

44 cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") 

45 if cuDriverGetVersion == NULL: 

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

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

48 if err != 0: 

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

50  

51 return driver_ver 

52  

53  

54  

55############################################################################### 

56# Wrapper init 

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

58  

59cdef object __symbol_lock = threading.Lock() 

60cdef bint __py_nvvm_init = False 

61  

62cdef void* __nvvmGetErrorString = NULL 

63cdef void* __nvvmVersion = NULL 

64cdef void* __nvvmIRVersion = NULL 

65cdef void* __nvvmCreateProgram = NULL 

66cdef void* __nvvmDestroyProgram = NULL 

67cdef void* __nvvmAddModuleToProgram = NULL 

68cdef void* __nvvmLazyAddModuleToProgram = NULL 

69cdef void* __nvvmCompileProgram = NULL 

70cdef void* __nvvmVerifyProgram = NULL 

71cdef void* __nvvmGetCompiledResultSize = NULL 

72cdef void* __nvvmGetCompiledResult = NULL 

73cdef void* __nvvmGetProgramLogSize = NULL 

74cdef void* __nvvmGetProgramLog = NULL 

75  

76  

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

78 cdef uintptr_t handle = load_nvidia_dynamic_lib("nvvm")._handle_uint 

79 return <void*>handle 

80  

81  

82cdef int _init_nvvm() except -1 nogil: 

83 global __py_nvvm_init 

84  

85 cdef void* handle = NULL 

86  

87 with gil, __symbol_lock: 

88 # Recheck the flag after obtaining the locks 

89 if __py_nvvm_init: 

90 return 0 

91  

92 # Load function 

93 global __nvvmGetErrorString 

94 __nvvmGetErrorString = dlsym(RTLD_DEFAULT, 'nvvmGetErrorString') 

95 if __nvvmGetErrorString == NULL: 

96 if handle == NULL: 

97 handle = load_library() 

98 __nvvmGetErrorString = dlsym(handle, 'nvvmGetErrorString') 

99  

100 global __nvvmVersion 

101 __nvvmVersion = dlsym(RTLD_DEFAULT, 'nvvmVersion') 

102 if __nvvmVersion == NULL: 

103 if handle == NULL: 

104 handle = load_library() 

105 __nvvmVersion = dlsym(handle, 'nvvmVersion') 

106  

107 global __nvvmIRVersion 

108 __nvvmIRVersion = dlsym(RTLD_DEFAULT, 'nvvmIRVersion') 

109 if __nvvmIRVersion == NULL: 

110 if handle == NULL: 

111 handle = load_library() 

112 __nvvmIRVersion = dlsym(handle, 'nvvmIRVersion') 

113  

114 global __nvvmCreateProgram 

115 __nvvmCreateProgram = dlsym(RTLD_DEFAULT, 'nvvmCreateProgram') 

116 if __nvvmCreateProgram == NULL: 

117 if handle == NULL: 

118 handle = load_library() 

119 __nvvmCreateProgram = dlsym(handle, 'nvvmCreateProgram') 

120  

121 global __nvvmDestroyProgram 

122 __nvvmDestroyProgram = dlsym(RTLD_DEFAULT, 'nvvmDestroyProgram') 

123 if __nvvmDestroyProgram == NULL: 

124 if handle == NULL: 

125 handle = load_library() 

126 __nvvmDestroyProgram = dlsym(handle, 'nvvmDestroyProgram') 

127  

128 global __nvvmAddModuleToProgram 

129 __nvvmAddModuleToProgram = dlsym(RTLD_DEFAULT, 'nvvmAddModuleToProgram') 

130 if __nvvmAddModuleToProgram == NULL: 

131 if handle == NULL: 

132 handle = load_library() 

133 __nvvmAddModuleToProgram = dlsym(handle, 'nvvmAddModuleToProgram') 

134  

135 global __nvvmLazyAddModuleToProgram 

136 __nvvmLazyAddModuleToProgram = dlsym(RTLD_DEFAULT, 'nvvmLazyAddModuleToProgram') 

137 if __nvvmLazyAddModuleToProgram == NULL: 

138 if handle == NULL: 

139 handle = load_library() 

140 __nvvmLazyAddModuleToProgram = dlsym(handle, 'nvvmLazyAddModuleToProgram') 

141  

142 global __nvvmCompileProgram 

143 __nvvmCompileProgram = dlsym(RTLD_DEFAULT, 'nvvmCompileProgram') 

144 if __nvvmCompileProgram == NULL: 

145 if handle == NULL: 

146 handle = load_library() 

147 __nvvmCompileProgram = dlsym(handle, 'nvvmCompileProgram') 

148  

149 global __nvvmVerifyProgram 

150 __nvvmVerifyProgram = dlsym(RTLD_DEFAULT, 'nvvmVerifyProgram') 

151 if __nvvmVerifyProgram == NULL: 

152 if handle == NULL: 

153 handle = load_library() 

154 __nvvmVerifyProgram = dlsym(handle, 'nvvmVerifyProgram') 

155  

156 global __nvvmGetCompiledResultSize 

157 __nvvmGetCompiledResultSize = dlsym(RTLD_DEFAULT, 'nvvmGetCompiledResultSize') 

158 if __nvvmGetCompiledResultSize == NULL: 

159 if handle == NULL: 

160 handle = load_library() 

161 __nvvmGetCompiledResultSize = dlsym(handle, 'nvvmGetCompiledResultSize') 

162  

163 global __nvvmGetCompiledResult 

164 __nvvmGetCompiledResult = dlsym(RTLD_DEFAULT, 'nvvmGetCompiledResult') 

165 if __nvvmGetCompiledResult == NULL: 

166 if handle == NULL: 

167 handle = load_library() 

168 __nvvmGetCompiledResult = dlsym(handle, 'nvvmGetCompiledResult') 

169  

170 global __nvvmGetProgramLogSize 

171 __nvvmGetProgramLogSize = dlsym(RTLD_DEFAULT, 'nvvmGetProgramLogSize') 

172 if __nvvmGetProgramLogSize == NULL: 

173 if handle == NULL: 

174 handle = load_library() 

175 __nvvmGetProgramLogSize = dlsym(handle, 'nvvmGetProgramLogSize') 

176  

177 global __nvvmGetProgramLog 

178 __nvvmGetProgramLog = dlsym(RTLD_DEFAULT, 'nvvmGetProgramLog') 

179 if __nvvmGetProgramLog == NULL: 

180 if handle == NULL: 

181 handle = load_library() 

182 __nvvmGetProgramLog = dlsym(handle, 'nvvmGetProgramLog') 

183  

184 __py_nvvm_init = True 

185 return 0 

186  

187  

188cdef inline int _check_or_init_nvvm() except -1 nogil: 

189 if __py_nvvm_init: 

190 return 0 

191  

192 return _init_nvvm() 

193  

194  

195cdef dict func_ptrs = None 

196  

197  

198cpdef dict _inspect_function_pointers(): 

199 global func_ptrs 

200 if func_ptrs is not None: 

201 return func_ptrs 

202  

203 _check_or_init_nvvm() 

204 cdef dict data = {} 

205  

206 global __nvvmGetErrorString 

207 data["__nvvmGetErrorString"] = <intptr_t>__nvvmGetErrorString 

208  

209 global __nvvmVersion 

210 data["__nvvmVersion"] = <intptr_t>__nvvmVersion 

211  

212 global __nvvmIRVersion 

213 data["__nvvmIRVersion"] = <intptr_t>__nvvmIRVersion 

214  

215 global __nvvmCreateProgram 

216 data["__nvvmCreateProgram"] = <intptr_t>__nvvmCreateProgram 

217  

218 global __nvvmDestroyProgram 

219 data["__nvvmDestroyProgram"] = <intptr_t>__nvvmDestroyProgram 

220  

221 global __nvvmAddModuleToProgram 

222 data["__nvvmAddModuleToProgram"] = <intptr_t>__nvvmAddModuleToProgram 

223  

224 global __nvvmLazyAddModuleToProgram 

225 data["__nvvmLazyAddModuleToProgram"] = <intptr_t>__nvvmLazyAddModuleToProgram 

226  

227 global __nvvmCompileProgram 

228 data["__nvvmCompileProgram"] = <intptr_t>__nvvmCompileProgram 

229  

230 global __nvvmVerifyProgram 

231 data["__nvvmVerifyProgram"] = <intptr_t>__nvvmVerifyProgram 

232  

233 global __nvvmGetCompiledResultSize 

234 data["__nvvmGetCompiledResultSize"] = <intptr_t>__nvvmGetCompiledResultSize 

235  

236 global __nvvmGetCompiledResult 

237 data["__nvvmGetCompiledResult"] = <intptr_t>__nvvmGetCompiledResult 

238  

239 global __nvvmGetProgramLogSize 

240 data["__nvvmGetProgramLogSize"] = <intptr_t>__nvvmGetProgramLogSize 

241  

242 global __nvvmGetProgramLog 

243 data["__nvvmGetProgramLog"] = <intptr_t>__nvvmGetProgramLog 

244  

245 func_ptrs = data 

246 return data 

247  

248  

249cpdef _inspect_function_pointer(str name): 

250 global func_ptrs 

251 if func_ptrs is None: 

252 func_ptrs = _inspect_function_pointers() 

253 return func_ptrs[name] 

254  

255  

256############################################################################### 

257# Wrapper functions 

258############################################################################### 

259  

260cdef const char* _nvvmGetErrorString(nvvmResult result) except?NULL nogil: 

261 global __nvvmGetErrorString 

262 _check_or_init_nvvm() 

263 if __nvvmGetErrorString == NULL: 

264 with gil: 

265 raise FunctionNotFoundError("function nvvmGetErrorString is not found") 

266 return (<const char* (*)(nvvmResult) noexcept nogil>__nvvmGetErrorString)( 

267 result) 

268  

269  

270cdef nvvmResult _nvvmVersion(int* major, int* minor) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

271 global __nvvmVersion 

272 _check_or_init_nvvm() 

273 if __nvvmVersion == NULL: 

274 with gil: 

275 raise FunctionNotFoundError("function nvvmVersion is not found") 

276 return (<nvvmResult (*)(int*, int*) noexcept nogil>__nvvmVersion)( 

277 major, minor) 

278  

279  

280cdef nvvmResult _nvvmIRVersion(int* majorIR, int* minorIR, int* majorDbg, int* minorDbg) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

281 global __nvvmIRVersion 

282 _check_or_init_nvvm() 

283 if __nvvmIRVersion == NULL: 

284 with gil: 

285 raise FunctionNotFoundError("function nvvmIRVersion is not found") 

286 return (<nvvmResult (*)(int*, int*, int*, int*) noexcept nogil>__nvvmIRVersion)( 

287 majorIR, minorIR, majorDbg, minorDbg) 

288  

289  

290cdef nvvmResult _nvvmCreateProgram(nvvmProgram* prog) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

291 global __nvvmCreateProgram 

292 _check_or_init_nvvm() 

293 if __nvvmCreateProgram == NULL: 

294 with gil: 

295 raise FunctionNotFoundError("function nvvmCreateProgram is not found") 

296 return (<nvvmResult (*)(nvvmProgram*) noexcept nogil>__nvvmCreateProgram)( 

297 prog) 

298  

299  

300cdef nvvmResult _nvvmDestroyProgram(nvvmProgram* prog) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

301 global __nvvmDestroyProgram 

302 _check_or_init_nvvm() 

303 if __nvvmDestroyProgram == NULL: 

304 with gil: 

305 raise FunctionNotFoundError("function nvvmDestroyProgram is not found") 

306 return (<nvvmResult (*)(nvvmProgram*) noexcept nogil>__nvvmDestroyProgram)( 

307 prog) 

308  

309  

310cdef nvvmResult _nvvmAddModuleToProgram(nvvmProgram prog, const char* buffer, size_t size, const char* name) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

311 global __nvvmAddModuleToProgram 

312 _check_or_init_nvvm() 

313 if __nvvmAddModuleToProgram == NULL: 

314 with gil: 

315 raise FunctionNotFoundError("function nvvmAddModuleToProgram is not found") 

316 return (<nvvmResult (*)(nvvmProgram, const char*, size_t, const char*) noexcept nogil>__nvvmAddModuleToProgram)( 

317 prog, buffer, size, name) 

318  

319  

320cdef nvvmResult _nvvmLazyAddModuleToProgram(nvvmProgram prog, const char* buffer, size_t size, const char* name) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

321 global __nvvmLazyAddModuleToProgram 

322 _check_or_init_nvvm() 

323 if __nvvmLazyAddModuleToProgram == NULL: 

324 with gil: 

325 raise FunctionNotFoundError("function nvvmLazyAddModuleToProgram is not found") 

326 return (<nvvmResult (*)(nvvmProgram, const char*, size_t, const char*) noexcept nogil>__nvvmLazyAddModuleToProgram)( 

327 prog, buffer, size, name) 

328  

329  

330cdef nvvmResult _nvvmCompileProgram(nvvmProgram prog, int numOptions, const char** options) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

331 global __nvvmCompileProgram 

332 _check_or_init_nvvm() 

333 if __nvvmCompileProgram == NULL: 

334 with gil: 

335 raise FunctionNotFoundError("function nvvmCompileProgram is not found") 

336 return (<nvvmResult (*)(nvvmProgram, int, const char**) noexcept nogil>__nvvmCompileProgram)( 

337 prog, numOptions, options) 

338  

339  

340cdef nvvmResult _nvvmVerifyProgram(nvvmProgram prog, int numOptions, const char** options) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

341 global __nvvmVerifyProgram 

342 _check_or_init_nvvm() 

343 if __nvvmVerifyProgram == NULL: 

344 with gil: 

345 raise FunctionNotFoundError("function nvvmVerifyProgram is not found") 

346 return (<nvvmResult (*)(nvvmProgram, int, const char**) noexcept nogil>__nvvmVerifyProgram)( 

347 prog, numOptions, options) 

348  

349  

350cdef nvvmResult _nvvmGetCompiledResultSize(nvvmProgram prog, size_t* bufferSizeRet) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

351 global __nvvmGetCompiledResultSize 

352 _check_or_init_nvvm() 

353 if __nvvmGetCompiledResultSize == NULL: 

354 with gil: 

355 raise FunctionNotFoundError("function nvvmGetCompiledResultSize is not found") 

356 return (<nvvmResult (*)(nvvmProgram, size_t*) noexcept nogil>__nvvmGetCompiledResultSize)( 

357 prog, bufferSizeRet) 

358  

359  

360cdef nvvmResult _nvvmGetCompiledResult(nvvmProgram prog, char* buffer) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

361 global __nvvmGetCompiledResult 

362 _check_or_init_nvvm() 

363 if __nvvmGetCompiledResult == NULL: 

364 with gil: 

365 raise FunctionNotFoundError("function nvvmGetCompiledResult is not found") 

366 return (<nvvmResult (*)(nvvmProgram, char*) noexcept nogil>__nvvmGetCompiledResult)( 

367 prog, buffer) 

368  

369  

370cdef nvvmResult _nvvmGetProgramLogSize(nvvmProgram prog, size_t* bufferSizeRet) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

371 global __nvvmGetProgramLogSize 

372 _check_or_init_nvvm() 

373 if __nvvmGetProgramLogSize == NULL: 

374 with gil: 

375 raise FunctionNotFoundError("function nvvmGetProgramLogSize is not found") 

376 return (<nvvmResult (*)(nvvmProgram, size_t*) noexcept nogil>__nvvmGetProgramLogSize)( 

377 prog, bufferSizeRet) 

378  

379  

380cdef nvvmResult _nvvmGetProgramLog(nvvmProgram prog, char* buffer) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 

381 global __nvvmGetProgramLog 

382 _check_or_init_nvvm() 

383 if __nvvmGetProgramLog == NULL: 

384 with gil: 

385 raise FunctionNotFoundError("function nvvmGetProgramLog is not found") 

386 return (<nvvmResult (*)(nvvmProgram, char*) noexcept nogil>__nvvmGetProgramLog)( 

387 prog, buffer)