Coverage for cuda/core/_utils/driver_cu_result_explanations

2# SPDX-License-Identifier: Apache-2.0

4# Like the runtime counterpart, this fallback is a deliberately frozen

5# compatibility snapshot, not a release-maintained mirror of CUDA's enums.

6# Do not update it past CUDA Toolkit v13.1.1. Bindings releases new enough to

7# define later codes provide explanations through enum-member docstrings; if an

8# older binding receives one from a newer driver, it falls through to

9# cuGetErrorString(). Synchronizing this table with later Toolkit releases would

10# restore the duplicate maintenance burden removed by PR #1860.

11# CUDA Toolkit v13.1.1

12_FALLBACK_EXPLANATIONS = {

13 0: (

14 "The API call returned with no errors. In the case of query calls, this"

15 " also means that the operation being queried is complete (see"

16 " ::cuEventQuery() and ::cuStreamQuery())."

17 ),

18 1: (

19 "This indicates that one or more of the parameters passed to the API call"

20 " is not within an acceptable range of values."

21 ),

22 2: (

23 "The API call failed because it was unable to allocate enough memory or"

24 " other resources to perform the requested operation."

25 ),

26 3: (

27 "This indicates that the CUDA driver has not been initialized with"

28 " ::cuInit() or that initialization has failed."

29 ),

30 4: "This indicates that the CUDA driver is in the process of shutting down.",

31 5: (

32 "This indicates profiler is not initialized for this run. This can"

33 " happen when the application is running with external profiling tools"

34 " like visual profiler."

35 ),

36 6: (

37 "This error return is deprecated as of CUDA 5.0. It is no longer an error"

38 " to attempt to enable/disable the profiling via ::cuProfilerStart or"

39 " ::cuProfilerStop without initialization."

40 ),

41 7: (

42 "This error return is deprecated as of CUDA 5.0. It is no longer an error"

43 " to call cuProfilerStart() when profiling is already enabled."

44 ),

45 8: (

46 "This error return is deprecated as of CUDA 5.0. It is no longer an error"

47 " to call cuProfilerStop() when profiling is already disabled."

48 ),

49 34: (

50 "This indicates that the CUDA driver that the application has loaded is a"

51 " stub library. Applications that run with the stub rather than a real"

52 " driver loaded will result in CUDA API returning this error."

53 ),

54 36: (

55 "This indicates that the API call requires a newer CUDA driver than the one"

56 " currently installed. Users should install an updated NVIDIA CUDA driver"

57 " to allow the API call to succeed."

58 ),

59 46: (

60 "This indicates that requested CUDA device is unavailable at the current"

61 " time. Devices are often unavailable due to use of"

62 " ::CU_COMPUTEMODE_EXCLUSIVE_PROCESS or ::CU_COMPUTEMODE_PROHIBITED."

63 ),

64 100: ("This indicates that no CUDA-capable devices were detected by the installed CUDA driver."),

65 101: (

66 "This indicates that the device ordinal supplied by the user does not"

67 " correspond to a valid CUDA device or that the action requested is"

68 " invalid for the specified device."

69 ),

70 102: "This error indicates that the Grid license is not applied.",

71 200: ("This indicates that the device kernel image is invalid. This can also indicate an invalid CUDA module."),

72 201: (

73 "This most frequently indicates that there is no context bound to the"

74 " current thread. This can also be returned if the context passed to an"

75 " API call is not a valid handle (such as a context that has had"

76 " ::cuCtxDestroy() invoked on it). This can also be returned if a user"

77 " mixes different API versions (i.e. 3010 context with 3020 API calls)."

78 " See ::cuCtxGetApiVersion() for more details."

79 " This can also be returned if the green context passed to an API call"

80 " was not converted to a ::CUcontext using ::cuCtxFromGreenCtx API."

81 ),

82 202: (

83 "This indicated that the context being supplied as a parameter to the"

84 " API call was already the active context."

85 " This error return is deprecated as of CUDA 3.2. It is no longer an"

86 " error to attempt to push the active context via ::cuCtxPushCurrent()."

87 ),

88 205: "This indicates that a map or register operation has failed.",

89 206: "This indicates that an unmap or unregister operation has failed.",

90 207: ("This indicates that the specified array is currently mapped and thus cannot be destroyed."),

91 208: "This indicates that the resource is already mapped.",

92 209: (

93 "This indicates that there is no kernel image available that is suitable"

94 " for the device. This can occur when a user specifies code generation"

95 " options for a particular CUDA source file that do not include the"

96 " corresponding device configuration."

97 ),

98 210: "This indicates that a resource has already been acquired.",

99 211: "This indicates that a resource is not mapped.",

100 212: ("This indicates that a mapped resource is not available for access as an array."),

101 213: ("This indicates that a mapped resource is not available for access as a pointer."),

102 214: ("This indicates that an uncorrectable ECC error was detected during execution."),

103 215: ("This indicates that the ::CUlimit passed to the API call is not supported by the active device."),

104 216: (

105 "This indicates that the ::CUcontext passed to the API call can"

106 " only be bound to a single CPU thread at a time but is already"

107 " bound to a CPU thread."

108 ),

109 217: ("This indicates that peer access is not supported across the given devices."),

110 218: "This indicates that a PTX JIT compilation failed.",

111 219: "This indicates an error with OpenGL or DirectX context.",

112 220: ("This indicates that an uncorrectable NVLink error was detected during the execution."),

113 221: "This indicates that the PTX JIT compiler library was not found.",

114 222: "This indicates that the provided PTX was compiled with an unsupported toolchain.",

115 223: "This indicates that the PTX JIT compilation was disabled.",

116 224: ("This indicates that the ::CUexecAffinityType passed to the API call is not supported by the active device."),

117 225: (

118 "This indicates that the code to be compiled by the PTX JIT contains unsupported call to cudaDeviceSynchronize."

119 ),

120 226: (

121 "This indicates that an exception occurred on the device that is now"

122 " contained by the GPU's error containment capability. Common causes are -"

123 " a. Certain types of invalid accesses of peer GPU memory over nvlink"

124 " b. Certain classes of hardware errors"

125 " This leaves the process in an inconsistent state and any further CUDA"

126 " work will return the same error. To continue using CUDA, the process must"

127 " be terminated and relaunched."

128 ),

129 300: (

130 "This indicates that the device kernel source is invalid. This includes"

131 " compilation/linker errors encountered in device code or user error."

132 ),

133 301: "This indicates that the file specified was not found.",

134 302: "This indicates that a link to a shared object failed to resolve.",

135 303: "This indicates that initialization of a shared object failed.",

136 304: "This indicates that an OS call failed.",

137 400: (

138 "This indicates that a resource handle passed to the API call was not"

139 " valid. Resource handles are opaque types like ::CUstream and ::CUevent."

140 ),

141 401: (

142 "This indicates that a resource required by the API call is not in a"

143 " valid state to perform the requested operation."

144 ),

145 402: (

146 "This indicates an attempt was made to introspect an object in a way that"

147 " would discard semantically important information. This is either due to"

148 " the object using funtionality newer than the API version used to"

149 " introspect it or omission of optional return arguments."

150 ),

151 500: (

152 "This indicates that a named symbol was not found. Examples of symbols"

153 " are global/constant variable names, driver function names, texture names,"

154 " and surface names."

155 ),

156 600: (

157 "This indicates that asynchronous operations issued previously have not"

158 " completed yet. This result is not actually an error, but must be indicated"

159 " differently than ::CUDA_SUCCESS (which indicates completion). Calls that"

160 " may return this value include ::cuEventQuery() and ::cuStreamQuery()."

161 ),

162 700: (

163 "While executing a kernel, the device encountered a"

164 " load or store instruction on an invalid memory address."

165 " This leaves the process in an inconsistent state and any further CUDA work"

166 " will return the same error. To continue using CUDA, the process must be terminated"

167 " and relaunched."

168 ),

169 701: (

170 "This indicates that a launch did not occur because it did not have"

171 " appropriate resources. This error usually indicates that the user has"

172 " attempted to pass too many arguments to the device kernel, or the"

173 " kernel launch specifies too many threads for the kernel's register"

174 " count. Passing arguments of the wrong size (i.e. a 64-bit pointer"

175 " when a 32-bit int is expected) is equivalent to passing too many"

176 " arguments and can also result in this error."

177 ),

178 702: (

179 "This indicates that the device kernel took too long to execute. This can"

180 " only occur if timeouts are enabled - see the device attribute"

181 " ::CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT for more information."

182 " This leaves the process in an inconsistent state and any further CUDA work"

183 " will return the same error. To continue using CUDA, the process must be terminated"

184 " and relaunched."

185 ),

186 703: ("This error indicates a kernel launch that uses an incompatible texturing mode."),

187 704: (

188 "This error indicates that a call to ::cuCtxEnablePeerAccess() is"

189 " trying to re-enable peer access to a context which has already"

190 " had peer access to it enabled."

191 ),

192 705: (

193 "This error indicates that ::cuCtxDisablePeerAccess() is"

194 " trying to disable peer access which has not been enabled yet"

195 " via ::cuCtxEnablePeerAccess()."

196 ),

197 708: ("This error indicates that the primary context for the specified device has already been initialized."),

198 709: (

199 "This error indicates that the context current to the calling thread"

200 " has been destroyed using ::cuCtxDestroy, or is a primary context which"

201 " has not yet been initialized."

202 ),

203 710: (

204 "A device-side assert triggered during kernel execution. The context"

205 " cannot be used anymore, and must be destroyed. All existing device"

206 " memory allocations from this context are invalid and must be"

207 " reconstructed if the program is to continue using CUDA."

208 ),

209 711: (

210 "This error indicates that the hardware resources required to enable"

211 " peer access have been exhausted for one or more of the devices"

212 " passed to ::cuCtxEnablePeerAccess()."

213 ),

214 712: ("This error indicates that the memory range passed to ::cuMemHostRegister() has already been registered."),

215 713: (

216 "This error indicates that the pointer passed to ::cuMemHostUnregister()"

217 " does not correspond to any currently registered memory region."

218 ),

219 714: (

220 "While executing a kernel, the device encountered a stack error."

221 " This can be due to stack corruption or exceeding the stack size limit."

222 " This leaves the process in an inconsistent state and any further CUDA work"

223 " will return the same error. To continue using CUDA, the process must be terminated"

224 " and relaunched."

225 ),

226 715: (

227 "While executing a kernel, the device encountered an illegal instruction."

228 " This leaves the process in an inconsistent state and any further CUDA work"

229 " will return the same error. To continue using CUDA, the process must be terminated"

230 " and relaunched."

231 ),

232 716: (

233 "While executing a kernel, the device encountered a load or store instruction"

234 " on a memory address which is not aligned."

235 " This leaves the process in an inconsistent state and any further CUDA work"

236 " will return the same error. To continue using CUDA, the process must be terminated"

237 " and relaunched."

238 ),

239 717: (

240 "While executing a kernel, the device encountered an instruction"

241 " which can only operate on memory locations in certain address spaces"

242 " (global, shared, or local), but was supplied a memory address not"

243 " belonging to an allowed address space."

244 " This leaves the process in an inconsistent state and any further CUDA work"

245 " will return the same error. To continue using CUDA, the process must be terminated"

246 " and relaunched."

247 ),

248 718: (

249 "While executing a kernel, the device program counter wrapped its address space."

250 " This leaves the process in an inconsistent state and any further CUDA work"

251 " will return the same error. To continue using CUDA, the process must be terminated"

252 " and relaunched."

253 ),

254 719: (

255 "An exception occurred on the device while executing a kernel. Common"

256 " causes include dereferencing an invalid device pointer and accessing"

257 " out of bounds shared memory. Less common cases can be system specific - more"

258 " information about these cases can be found in the system specific user guide."

259 " This leaves the process in an inconsistent state and any further CUDA work"

260 " will return the same error. To continue using CUDA, the process must be terminated"

261 " and relaunched."

262 ),

263 720: (

264 "This error indicates that the number of blocks launched per grid for a kernel that was"

265 " launched via either ::cuLaunchCooperativeKernel or ::cuLaunchCooperativeKernelMultiDevice"

266 " exceeds the maximum number of blocks as allowed by ::cuOccupancyMaxActiveBlocksPerMultiprocessor"

267 " or ::cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags times the number of multiprocessors"

268 " as specified by the device attribute ::CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT."

269 ),

270 721: (

271 "An exception occurred on the device while exiting a kernel using tensor memory: the"

272 " tensor memory was not completely deallocated. This leaves the process in an inconsistent"

273 " state and any further CUDA work will return the same error. To continue using CUDA, the"

274 " process must be terminated and relaunched."

275 ),

276 800: "This error indicates that the attempted operation is not permitted.",

277 801: ("This error indicates that the attempted operation is not supported on the current system or device."),

278 802: (

279 "This error indicates that the system is not yet ready to start any CUDA"

280 " work. To continue using CUDA, verify the system configuration is in a"

281 " valid state and all required driver daemons are actively running."

282 " More information about this error can be found in the system specific"

283 " user guide."

284 ),

285 803: (

286 "This error indicates that there is a mismatch between the versions of"

287 " the display driver and the CUDA driver. Refer to the compatibility documentation"

288 " for supported versions."

289 ),

290 804: (

291 "This error indicates that the system was upgraded to run with forward compatibility"

292 " but the visible hardware detected by CUDA does not support this configuration."

293 " Refer to the compatibility documentation for the supported hardware matrix or ensure"

294 " that only supported hardware is visible during initialization via the CUDA_VISIBLE_DEVICES"

295 " environment variable."

296 ),

297 805: "This error indicates that the MPS client failed to connect to the MPS control daemon or the MPS server.",

298 806: "This error indicates that the remote procedural call between the MPS server and the MPS client failed.",

299 807: (

300 "This error indicates that the MPS server is not ready to accept new MPS client requests."

301 " This error can be returned when the MPS server is in the process of recovering from a fatal failure."

302 ),

303 808: "This error indicates that the hardware resources required to create MPS client have been exhausted.",

304 809: "This error indicates the the hardware resources required to support device connections have been exhausted.",

305 810: "This error indicates that the MPS client has been terminated by the server. To continue using CUDA, the process must be terminated and relaunched.",

306 811: "This error indicates that the module is using CUDA Dynamic Parallelism, but the current configuration, like MPS, does not support it.",

307 812: "This error indicates that a module contains an unsupported interaction between different versions of CUDA Dynamic Parallelism.",

308 900: ("This error indicates that the operation is not permitted when the stream is capturing."),

309 901: (

310 "This error indicates that the current capture sequence on the stream"

311 " has been invalidated due to a previous error."

312 ),

313 902: (

314 "This error indicates that the operation would have resulted in a merge of two independent capture sequences."

315 ),

316 903: "This error indicates that the capture was not initiated in this stream.",

317 904: ("This error indicates that the capture sequence contains a fork that was not joined to the primary stream."),

318 905: (

319 "This error indicates that a dependency would have been created which"

320 " crosses the capture sequence boundary. Only implicit in-stream ordering"

321 " dependencies are allowed to cross the boundary."

322 ),

323 906: ("This error indicates a disallowed implicit dependency on a current capture sequence from cudaStreamLegacy."),

324 907: (

325 "This error indicates that the operation is not permitted on an event which"

326 " was last recorded in a capturing stream."

327 ),

328 908: (

329 "A stream capture sequence not initiated with the ::CU_STREAM_CAPTURE_MODE_RELAXED"

330 " argument to ::cuStreamBeginCapture was passed to ::cuStreamEndCapture in a"

331 " different thread."

332 ),

333 909: "This error indicates that the timeout specified for the wait operation has lapsed.",

334 910: (

335 "This error indicates that the graph update was not performed because it included"

336 " changes which violated constraints specific to instantiated graph update."

337 ),

338 911: (

339 "This indicates that an async error has occurred in a device outside of CUDA."

340 " If CUDA was waiting for an external device's signal before consuming shared data,"

341 " the external device signaled an error indicating that the data is not valid for"

342 " consumption. This leaves the process in an inconsistent state and any further CUDA"

343 " work will return the same error. To continue using CUDA, the process must be"

344 " terminated and relaunched."

345 ),

346 912: "Indicates a kernel launch error due to cluster misconfiguration.",

347 913: ("Indiciates a function handle is not loaded when calling an API that requires a loaded function."),

348 914: ("This error indicates one or more resources passed in are not valid resource types for the operation."),

349 915: ("This error indicates one or more resources are insufficient or non-applicable for the operation."),

350 916: ("This error indicates that an error happened during the key rotation sequence."),

351 917: (

352 "This error indicates that the requested operation is not permitted because the"

353 " stream is in a detached state. This can occur if the green context associated"

354 " with the stream has been destroyed, limiting the stream's operational capabilities."

355 ),

356 999: "This indicates that an unknown internal error has occurred.",

357}

Coverage for cuda/core/_utils/driver_cu_result_explanations_frozen.py: 0.00%

1 statements