Coverage for cuda / bindings / runtime.pyx: 27%

1# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 

2# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE 

3  

4# This code was automatically generated with version 13.1.0. Do not modify it directly. 

5from typing import Any, Optional 

6from enum import IntEnum 

7import cython 

8import ctypes 

9from libc.stdlib cimport calloc, malloc, free 

10from libc cimport string 

11from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t, uintptr_t 

12from libc.stddef cimport wchar_t 

13from libc.limits cimport CHAR_MIN 

14from libcpp.vector cimport vector 

15from cpython.buffer cimport PyObject_CheckBuffer, PyObject_GetBuffer, PyBuffer_Release, PyBUF_SIMPLE, PyBUF_ANY_CONTIGUOUS 

16from cpython.bytes cimport PyBytes_FromStringAndSize 

17import cuda.bindings.driver 

18from libcpp.map cimport map 

19  

20import cuda.bindings.driver as _driver 

21_driver = _driver.__dict__ 

22include "_lib/utils.pxi" 

23  

24ctypedef unsigned long long signed_char_ptr 

25ctypedef unsigned long long unsigned_char_ptr 

26ctypedef unsigned long long char_ptr 

27ctypedef unsigned long long short_ptr 

28ctypedef unsigned long long unsigned_short_ptr 

29ctypedef unsigned long long int_ptr 

30ctypedef unsigned long long long_int_ptr 

31ctypedef unsigned long long long_long_int_ptr 

32ctypedef unsigned long long unsigned_int_ptr 

33ctypedef unsigned long long unsigned_long_int_ptr 

34ctypedef unsigned long long unsigned_long_long_int_ptr 

35ctypedef unsigned long long uint32_t_ptr 

36ctypedef unsigned long long uint64_t_ptr 

37ctypedef unsigned long long int32_t_ptr 

38ctypedef unsigned long long int64_t_ptr 

39ctypedef unsigned long long unsigned_ptr 

40ctypedef unsigned long long unsigned_long_long_ptr 

41ctypedef unsigned long long long_long_ptr 

42ctypedef unsigned long long size_t_ptr 

43ctypedef unsigned long long long_ptr 

44ctypedef unsigned long long float_ptr 

45ctypedef unsigned long long double_ptr 

46ctypedef unsigned long long void_ptr 

47  

48#: Default page-locked allocation flag 

49cudaHostAllocDefault = cyruntime.cudaHostAllocDefault 

50  

51#: Pinned memory accessible by all CUDA contexts 

52cudaHostAllocPortable = cyruntime.cudaHostAllocPortable 

53  

54#: Map allocation into device space 

55cudaHostAllocMapped = cyruntime.cudaHostAllocMapped 

56  

57#: Write-combined memory 

58cudaHostAllocWriteCombined = cyruntime.cudaHostAllocWriteCombined 

59  

60#: Default host memory registration flag 

61cudaHostRegisterDefault = cyruntime.cudaHostRegisterDefault 

62  

63#: Pinned memory accessible by all CUDA contexts 

64cudaHostRegisterPortable = cyruntime.cudaHostRegisterPortable 

65  

66#: Map registered memory into device space 

67cudaHostRegisterMapped = cyruntime.cudaHostRegisterMapped 

68  

69#: Memory-mapped I/O space 

70cudaHostRegisterIoMemory = cyruntime.cudaHostRegisterIoMemory 

71  

72#: Memory-mapped read-only 

73cudaHostRegisterReadOnly = cyruntime.cudaHostRegisterReadOnly 

74  

75#: Default peer addressing enable flag 

76cudaPeerAccessDefault = cyruntime.cudaPeerAccessDefault 

77  

78#: Default stream flag 

79cudaStreamDefault = cyruntime.cudaStreamDefault 

80  

81#: Stream does not synchronize with stream 0 (the NULL stream) 

82cudaStreamNonBlocking = cyruntime.cudaStreamNonBlocking 

83  

84#: Legacy stream handle 

85#: 

86#: Stream handle that can be passed as a cudaStream_t to use an implicit 

87#: stream with legacy synchronization behavior. 

88#: 

89#: See details of the \link_sync_behavior 

90cudaStreamLegacy = cyruntime.cudaStreamLegacy 

91  

92#: Per-thread stream handle 

93#: 

94#: Stream handle that can be passed as a cudaStream_t to use an implicit 

95#: stream with per-thread synchronization behavior. 

96#: 

97#: See details of the \link_sync_behavior 

98cudaStreamPerThread = cyruntime.cudaStreamPerThread 

99  

100#: Default event flag 

101cudaEventDefault = cyruntime.cudaEventDefault 

102  

103#: Event uses blocking synchronization 

104cudaEventBlockingSync = cyruntime.cudaEventBlockingSync 

105  

106#: Event will not record timing data 

107cudaEventDisableTiming = cyruntime.cudaEventDisableTiming 

108  

109#: Event is suitable for interprocess use. cudaEventDisableTiming must be 

110#: set 

111cudaEventInterprocess = cyruntime.cudaEventInterprocess 

112  

113#: Default event record flag 

114cudaEventRecordDefault = cyruntime.cudaEventRecordDefault 

115  

116#: Event is captured in the graph as an external event node when performing 

117#: stream capture 

118cudaEventRecordExternal = cyruntime.cudaEventRecordExternal 

119  

120#: Default event wait flag 

121cudaEventWaitDefault = cyruntime.cudaEventWaitDefault 

122  

123#: Event is captured in the graph as an external event node when performing 

124#: stream capture 

125cudaEventWaitExternal = cyruntime.cudaEventWaitExternal 

126  

127#: Device flag - Automatic scheduling 

128cudaDeviceScheduleAuto = cyruntime.cudaDeviceScheduleAuto 

129  

130#: Device flag - Spin default scheduling 

131cudaDeviceScheduleSpin = cyruntime.cudaDeviceScheduleSpin 

132  

133#: Device flag - Yield default scheduling 

134cudaDeviceScheduleYield = cyruntime.cudaDeviceScheduleYield 

135  

136#: Device flag - Use blocking synchronization 

137cudaDeviceScheduleBlockingSync = cyruntime.cudaDeviceScheduleBlockingSync 

138  

139#: Device flag - Use blocking synchronization [Deprecated] 

140cudaDeviceBlockingSync = cyruntime.cudaDeviceBlockingSync 

141  

142#: Device schedule flags mask 

143cudaDeviceScheduleMask = cyruntime.cudaDeviceScheduleMask 

144  

145#: Device flag - Support mapped pinned allocations 

146cudaDeviceMapHost = cyruntime.cudaDeviceMapHost 

147  

148#: Device flag - Keep local memory allocation after launch 

149cudaDeviceLmemResizeToMax = cyruntime.cudaDeviceLmemResizeToMax 

150  

151#: Device flag - Ensure synchronous memory operations on this context will 

152#: synchronize 

153cudaDeviceSyncMemops = cyruntime.cudaDeviceSyncMemops 

154  

155#: Device flags mask 

156cudaDeviceMask = cyruntime.cudaDeviceMask 

157  

158#: Default CUDA array allocation flag 

159cudaArrayDefault = cyruntime.cudaArrayDefault 

160  

161#: Must be set in cudaMalloc3DArray to create a layered CUDA array 

162cudaArrayLayered = cyruntime.cudaArrayLayered 

163  

164#: Must be set in cudaMallocArray or cudaMalloc3DArray in order to bind 

165#: surfaces to the CUDA array 

166cudaArraySurfaceLoadStore = cyruntime.cudaArraySurfaceLoadStore 

167  

168#: Must be set in cudaMalloc3DArray to create a cubemap CUDA array 

169cudaArrayCubemap = cyruntime.cudaArrayCubemap 

170  

171#: Must be set in cudaMallocArray or cudaMalloc3DArray in order to perform 

172#: texture gather operations on the CUDA array 

173cudaArrayTextureGather = cyruntime.cudaArrayTextureGather 

174  

175#: Must be set in cudaExternalMemoryGetMappedMipmappedArray if the 

176#: mipmapped array is used as a color target in a graphics API 

177cudaArrayColorAttachment = cyruntime.cudaArrayColorAttachment 

178  

179#: Must be set in cudaMallocArray, cudaMalloc3DArray or 

180#: cudaMallocMipmappedArray in order to create a sparse CUDA array or CUDA 

181#: mipmapped array 

182cudaArraySparse = cyruntime.cudaArraySparse 

183  

184#: Must be set in cudaMallocArray, cudaMalloc3DArray or 

185#: cudaMallocMipmappedArray in order to create a deferred mapping CUDA 

186#: array or CUDA mipmapped array 

187cudaArrayDeferredMapping = cyruntime.cudaArrayDeferredMapping 

188  

189#: Automatically enable peer access between remote devices as needed 

190cudaIpcMemLazyEnablePeerAccess = cyruntime.cudaIpcMemLazyEnablePeerAccess 

191  

192#: Memory can be accessed by any stream on any device 

193cudaMemAttachGlobal = cyruntime.cudaMemAttachGlobal 

194  

195#: Memory cannot be accessed by any stream on any device 

196cudaMemAttachHost = cyruntime.cudaMemAttachHost 

197  

198#: Memory can only be accessed by a single stream on the associated device 

199cudaMemAttachSingle = cyruntime.cudaMemAttachSingle 

200  

201#: Default behavior 

202cudaOccupancyDefault = cyruntime.cudaOccupancyDefault 

203  

204#: Assume global caching is enabled and cannot be automatically turned off 

205cudaOccupancyDisableCachingOverride = cyruntime.cudaOccupancyDisableCachingOverride 

206  

207#: Device id that represents the CPU 

208cudaCpuDeviceId = cyruntime.cudaCpuDeviceId 

209  

210#: Device id that represents an invalid device 

211cudaInvalidDeviceId = cyruntime.cudaInvalidDeviceId 

212  

213#: Tell the CUDA runtime that DeviceFlags is being set in cudaInitDevice 

214#: call 

215cudaInitDeviceFlagsAreValid = cyruntime.cudaInitDeviceFlagsAreValid 

216  

217#: Indicates that the layered sparse CUDA array or CUDA mipmapped array has 

218#: a single mip tail region for all layers 

219cudaArraySparsePropertiesSingleMipTail = cyruntime.cudaArraySparsePropertiesSingleMipTail 

220  

221#: This flag, if set, indicates that the memory will be used as a buffer 

222#: for hardware accelerated decompression. 

223cudaMemPoolCreateUsageHwDecompress = cyruntime.cudaMemPoolCreateUsageHwDecompress 

224  

225#: CUDA IPC Handle Size 

226CUDA_IPC_HANDLE_SIZE = cyruntime.CUDA_IPC_HANDLE_SIZE 

227  

228#: Indicates that the external memory object is a dedicated resource 

229cudaExternalMemoryDedicated = cyruntime.cudaExternalMemoryDedicated 

230  

231#: When the /p flags parameter of 

232#: :py:obj:`~.cudaExternalSemaphoreSignalParams` contains this flag, it 

233#: indicates that signaling an external semaphore object should skip 

234#: performing appropriate memory synchronization operations over all the 

235#: external memory objects that are imported as 

236#: :py:obj:`~.cudaExternalMemoryHandleTypeNvSciBuf`, which otherwise are 

237#: performed by default to ensure data coherency with other importers of 

238#: the same NvSciBuf memory objects. 

239cudaExternalSemaphoreSignalSkipNvSciBufMemSync = cyruntime.cudaExternalSemaphoreSignalSkipNvSciBufMemSync 

240  

241#: When the /p flags parameter of 

242#: :py:obj:`~.cudaExternalSemaphoreWaitParams` contains this flag, it 

243#: indicates that waiting an external semaphore object should skip 

244#: performing appropriate memory synchronization operations over all the 

245#: external memory objects that are imported as 

246#: :py:obj:`~.cudaExternalMemoryHandleTypeNvSciBuf`, which otherwise are 

247#: performed by default to ensure data coherency with other importers of 

248#: the same NvSciBuf memory objects. 

249cudaExternalSemaphoreWaitSkipNvSciBufMemSync = cyruntime.cudaExternalSemaphoreWaitSkipNvSciBufMemSync 

250  

251#: When /p flags of :py:obj:`~.cudaDeviceGetNvSciSyncAttributes` is set to 

252#: this, it indicates that application need signaler specific NvSciSyncAttr 

253#: to be filled by :py:obj:`~.cudaDeviceGetNvSciSyncAttributes`. 

254cudaNvSciSyncAttrSignal = cyruntime.cudaNvSciSyncAttrSignal 

255  

256#: When /p flags of :py:obj:`~.cudaDeviceGetNvSciSyncAttributes` is set to 

257#: this, it indicates that application need waiter specific NvSciSyncAttr 

258#: to be filled by :py:obj:`~.cudaDeviceGetNvSciSyncAttributes`. 

259cudaNvSciSyncAttrWait = cyruntime.cudaNvSciSyncAttrWait 

260  

261#: This port activates when the kernel has finished executing. 

262cudaGraphKernelNodePortDefault = cyruntime.cudaGraphKernelNodePortDefault 

263  

264#: This port activates when all blocks of the kernel have performed 

265#: cudaTriggerProgrammaticLaunchCompletion() or have terminated. It must be 

266#: used with edge type :py:obj:`~.cudaGraphDependencyTypeProgrammatic`. See 

267#: also :py:obj:`~.cudaLaunchAttributeProgrammaticEvent`. 

268cudaGraphKernelNodePortProgrammatic = cyruntime.cudaGraphKernelNodePortProgrammatic 

269  

270#: This port activates when all blocks of the kernel have begun execution. 

271#: See also :py:obj:`~.cudaLaunchAttributeLaunchCompletionEvent`. 

272cudaGraphKernelNodePortLaunchCompletion = cyruntime.cudaGraphKernelNodePortLaunchCompletion 

273  

274cudaStreamAttributeAccessPolicyWindow = cyruntime.cudaStreamAttributeAccessPolicyWindow 

275  

276cudaStreamAttributeSynchronizationPolicy = cyruntime.cudaStreamAttributeSynchronizationPolicy 

277  

278cudaStreamAttributeMemSyncDomainMap = cyruntime.cudaStreamAttributeMemSyncDomainMap 

279  

280cudaStreamAttributeMemSyncDomain = cyruntime.cudaStreamAttributeMemSyncDomain 

281  

282cudaStreamAttributePriority = cyruntime.cudaStreamAttributePriority 

283  

284cudaKernelNodeAttributeAccessPolicyWindow = cyruntime.cudaKernelNodeAttributeAccessPolicyWindow 

285  

286cudaKernelNodeAttributeCooperative = cyruntime.cudaKernelNodeAttributeCooperative 

287  

288cudaKernelNodeAttributePriority = cyruntime.cudaKernelNodeAttributePriority 

289  

290cudaKernelNodeAttributeClusterDimension = cyruntime.cudaKernelNodeAttributeClusterDimension 

291  

292cudaKernelNodeAttributeClusterSchedulingPolicyPreference = cyruntime.cudaKernelNodeAttributeClusterSchedulingPolicyPreference 

293  

294cudaKernelNodeAttributeMemSyncDomainMap = cyruntime.cudaKernelNodeAttributeMemSyncDomainMap 

295  

296cudaKernelNodeAttributeMemSyncDomain = cyruntime.cudaKernelNodeAttributeMemSyncDomain 

297  

298cudaKernelNodeAttributePreferredSharedMemoryCarveout = cyruntime.cudaKernelNodeAttributePreferredSharedMemoryCarveout 

299  

300cudaKernelNodeAttributeDeviceUpdatableKernelNode = cyruntime.cudaKernelNodeAttributeDeviceUpdatableKernelNode 

301  

302cudaKernelNodeAttributeNvlinkUtilCentricScheduling = cyruntime.cudaKernelNodeAttributeNvlinkUtilCentricScheduling 

303  

304cudaSurfaceType1D = cyruntime.cudaSurfaceType1D 

305  

306cudaSurfaceType2D = cyruntime.cudaSurfaceType2D 

307  

308cudaSurfaceType3D = cyruntime.cudaSurfaceType3D 

309  

310cudaSurfaceTypeCubemap = cyruntime.cudaSurfaceTypeCubemap 

311  

312cudaSurfaceType1DLayered = cyruntime.cudaSurfaceType1DLayered 

313  

314cudaSurfaceType2DLayered = cyruntime.cudaSurfaceType2DLayered 

315  

316cudaSurfaceTypeCubemapLayered = cyruntime.cudaSurfaceTypeCubemapLayered 

317  

318cudaTextureType1D = cyruntime.cudaTextureType1D 

319  

320cudaTextureType2D = cyruntime.cudaTextureType2D 

321  

322cudaTextureType3D = cyruntime.cudaTextureType3D 

323  

324cudaTextureTypeCubemap = cyruntime.cudaTextureTypeCubemap 

325  

326cudaTextureType1DLayered = cyruntime.cudaTextureType1DLayered 

327  

328cudaTextureType2DLayered = cyruntime.cudaTextureType2DLayered 

329  

330cudaTextureTypeCubemapLayered = cyruntime.cudaTextureTypeCubemapLayered 

331  

332#: CUDA Runtime API Version 

333CUDART_VERSION = cyruntime.CUDART_VERSION 

334  

335__CUDART_API_VERSION = cyruntime.__CUDART_API_VERSION 

336  

337#: Maximum number of planes per frame 

338CUDA_EGL_MAX_PLANES = cyruntime.CUDA_EGL_MAX_PLANES 

339  

340class cudaError_t(IntEnum): 

341 """ 

342 impl_private CUDA error types 

343 """ 

344  

345 #: The API call returned with no errors. In the case of query calls, 

346 #: this also means that the operation being queried is complete (see 

347 #: :py:obj:`~.cudaEventQuery()` and :py:obj:`~.cudaStreamQuery()`). 

348 cudaSuccess = cyruntime.cudaError.cudaSuccess 

349  

350 #: This indicates that one or more of the parameters passed to the API 

351 #: call is not within an acceptable range of values. 

352 cudaErrorInvalidValue = cyruntime.cudaError.cudaErrorInvalidValue 

353  

354 #: The API call failed because it was unable to allocate enough memory 

355 #: or other resources to perform the requested operation. 

356 cudaErrorMemoryAllocation = cyruntime.cudaError.cudaErrorMemoryAllocation 

357  

358 #: The API call failed because the CUDA driver and runtime could not be 

359 #: initialized. 

360 cudaErrorInitializationError = cyruntime.cudaError.cudaErrorInitializationError 

361  

362 #: This indicates that a CUDA Runtime API call cannot be executed 

363 #: because it is being called during process shut down, at a point in 

364 #: time after CUDA driver has been unloaded. 

365 cudaErrorCudartUnloading = cyruntime.cudaError.cudaErrorCudartUnloading 

366  

367 #: This indicates profiler is not initialized for this run. This can 

368 #: happen when the application is running with external profiling tools 

369 #: like visual profiler. 

370 cudaErrorProfilerDisabled = cyruntime.cudaError.cudaErrorProfilerDisabled 

371  

372 #: [Deprecated] 

373 cudaErrorProfilerNotInitialized = cyruntime.cudaError.cudaErrorProfilerNotInitialized 

374  

375 #: [Deprecated] 

376 cudaErrorProfilerAlreadyStarted = cyruntime.cudaError.cudaErrorProfilerAlreadyStarted 

377  

378 #: [Deprecated] 

379 cudaErrorProfilerAlreadyStopped = cyruntime.cudaError.cudaErrorProfilerAlreadyStopped 

380  

381 #: This indicates that a kernel launch is requesting resources that can 

382 #: never be satisfied by the current device. Requesting more shared 

383 #: memory per block than the device supports will trigger this error, 

384 #: as will requesting too many threads or blocks. See 

385 #: :py:obj:`~.cudaDeviceProp` for more device limitations. 

386 cudaErrorInvalidConfiguration = cyruntime.cudaError.cudaErrorInvalidConfiguration 

387  

388 #: This indicates that one or more of the pitch-related parameters 

389 #: passed to the API call is not within the acceptable range for pitch. 

390 cudaErrorInvalidPitchValue = cyruntime.cudaError.cudaErrorInvalidPitchValue 

391  

392 #: This indicates that the symbol name/identifier passed to the API 

393 #: call is not a valid name or identifier. 

394 cudaErrorInvalidSymbol = cyruntime.cudaError.cudaErrorInvalidSymbol 

395  

396 #: This indicates that at least one host pointer passed to the API call 

397 #: is not a valid host pointer. [Deprecated] 

398 cudaErrorInvalidHostPointer = cyruntime.cudaError.cudaErrorInvalidHostPointer 

399  

400 #: This indicates that at least one device pointer passed to the API 

401 #: call is not a valid device pointer. [Deprecated] 

402 cudaErrorInvalidDevicePointer = cyruntime.cudaError.cudaErrorInvalidDevicePointer 

403  

404 #: This indicates that the texture passed to the API call is not a 

405 #: valid texture. 

406 cudaErrorInvalidTexture = cyruntime.cudaError.cudaErrorInvalidTexture 

407  

408 #: This indicates that the texture binding is not valid. This occurs if 

409 #: you call :py:obj:`~.cudaGetTextureAlignmentOffset()` with an unbound 

410 #: texture. 

411 cudaErrorInvalidTextureBinding = cyruntime.cudaError.cudaErrorInvalidTextureBinding 

412  

413 #: This indicates that the channel descriptor passed to the API call is 

414 #: not valid. This occurs if the format is not one of the formats 

415 #: specified by :py:obj:`~.cudaChannelFormatKind`, or if one of the 

416 #: dimensions is invalid. 

417 cudaErrorInvalidChannelDescriptor = cyruntime.cudaError.cudaErrorInvalidChannelDescriptor 

418  

419 #: This indicates that the direction of the memcpy passed to the API 

420 #: call is not one of the types specified by 

421 #: :py:obj:`~.cudaMemcpyKind`. 

422 cudaErrorInvalidMemcpyDirection = cyruntime.cudaError.cudaErrorInvalidMemcpyDirection 

423  

424 #: This indicated that the user has taken the address of a constant 

425 #: variable, which was forbidden up until the CUDA 3.1 release. 

426 #: [Deprecated] 

427 cudaErrorAddressOfConstant = cyruntime.cudaError.cudaErrorAddressOfConstant 

428  

429 #: This indicated that a texture fetch was not able to be performed. 

430 #: This was previously used for device emulation of texture operations. 

431 #: [Deprecated] 

432 cudaErrorTextureFetchFailed = cyruntime.cudaError.cudaErrorTextureFetchFailed 

433  

434 #: This indicated that a texture was not bound for access. This was 

435 #: previously used for device emulation of texture operations. 

436 #: [Deprecated] 

437 cudaErrorTextureNotBound = cyruntime.cudaError.cudaErrorTextureNotBound 

438  

439 #: This indicated that a synchronization operation had failed. This was 

440 #: previously used for some device emulation functions. [Deprecated] 

441 cudaErrorSynchronizationError = cyruntime.cudaError.cudaErrorSynchronizationError 

442  

443 #: This indicates that a non-float texture was being accessed with 

444 #: linear filtering. This is not supported by CUDA. 

445 cudaErrorInvalidFilterSetting = cyruntime.cudaError.cudaErrorInvalidFilterSetting 

446  

447 #: This indicates that an attempt was made to read an unsupported data 

448 #: type as a normalized float. This is not supported by CUDA. 

449 cudaErrorInvalidNormSetting = cyruntime.cudaError.cudaErrorInvalidNormSetting 

450  

451 #: Mixing of device and device emulation code was not allowed. 

452 #: [Deprecated] 

453 cudaErrorMixedDeviceExecution = cyruntime.cudaError.cudaErrorMixedDeviceExecution 

454  

455 #: This indicates that the API call is not yet implemented. Production 

456 #: releases of CUDA will never return this error. [Deprecated] 

457 cudaErrorNotYetImplemented = cyruntime.cudaError.cudaErrorNotYetImplemented 

458  

459 #: This indicated that an emulated device pointer exceeded the 32-bit 

460 #: address range. [Deprecated] 

461 cudaErrorMemoryValueTooLarge = cyruntime.cudaError.cudaErrorMemoryValueTooLarge 

462  

463 #: This indicates that the CUDA driver that the application has loaded 

464 #: is a stub library. Applications that run with the stub rather than a 

465 #: real driver loaded will result in CUDA API returning this error. 

466 cudaErrorStubLibrary = cyruntime.cudaError.cudaErrorStubLibrary 

467  

468 #: This indicates that the installed NVIDIA CUDA driver is older than 

469 #: the CUDA runtime library. This is not a supported configuration. 

470 #: Users should install an updated NVIDIA display driver to allow the 

471 #: application to run. 

472 cudaErrorInsufficientDriver = cyruntime.cudaError.cudaErrorInsufficientDriver 

473  

474 #: This indicates that the API call requires a newer CUDA driver than 

475 #: the one currently installed. Users should install an updated NVIDIA 

476 #: CUDA driver to allow the API call to succeed. 

477 cudaErrorCallRequiresNewerDriver = cyruntime.cudaError.cudaErrorCallRequiresNewerDriver 

478  

479 #: This indicates that the surface passed to the API call is not a 

480 #: valid surface. 

481 cudaErrorInvalidSurface = cyruntime.cudaError.cudaErrorInvalidSurface 

482  

483 #: This indicates that multiple global or constant variables (across 

484 #: separate CUDA source files in the application) share the same string 

485 #: name. 

486 cudaErrorDuplicateVariableName = cyruntime.cudaError.cudaErrorDuplicateVariableName 

487  

488 #: This indicates that multiple textures (across separate CUDA source 

489 #: files in the application) share the same string name. 

490 cudaErrorDuplicateTextureName = cyruntime.cudaError.cudaErrorDuplicateTextureName 

491  

492 #: This indicates that multiple surfaces (across separate CUDA source 

493 #: files in the application) share the same string name. 

494 cudaErrorDuplicateSurfaceName = cyruntime.cudaError.cudaErrorDuplicateSurfaceName 

495  

496 #: This indicates that all CUDA devices are busy or unavailable at the 

497 #: current time. Devices are often busy/unavailable due to use of 

498 #: :py:obj:`~.cudaComputeModeProhibited`, 

499 #: :py:obj:`~.cudaComputeModeExclusiveProcess`, or when long running 

500 #: CUDA kernels have filled up the GPU and are blocking new work from 

501 #: starting. They can also be unavailable due to memory constraints on 

502 #: a device that already has active CUDA work being performed. 

503 cudaErrorDevicesUnavailable = cyruntime.cudaError.cudaErrorDevicesUnavailable 

504  

505 #: This indicates that the current context is not compatible with this 

506 #: the CUDA Runtime. This can only occur if you are using CUDA 

507 #: Runtime/Driver interoperability and have created an existing Driver 

508 #: context using the driver API. The Driver context may be incompatible 

509 #: either because the Driver context was created using an older version 

510 #: of the API, because the Runtime API call expects a primary driver 

511 #: context and the Driver context is not primary, or because the Driver 

512 #: context has been destroyed. Please see :py:obj:`~.Interactions`with 

513 #: the CUDA Driver API" for more information. 

514 cudaErrorIncompatibleDriverContext = cyruntime.cudaError.cudaErrorIncompatibleDriverContext 

515  

516 #: The device function being invoked (usually via 

517 #: :py:obj:`~.cudaLaunchKernel()`) was not previously configured via 

518 #: the :py:obj:`~.cudaConfigureCall()` function. 

519 cudaErrorMissingConfiguration = cyruntime.cudaError.cudaErrorMissingConfiguration 

520  

521 #: This indicated that a previous kernel launch failed. This was 

522 #: previously used for device emulation of kernel launches. 

523 #: [Deprecated] 

524 cudaErrorPriorLaunchFailure = cyruntime.cudaError.cudaErrorPriorLaunchFailure 

525  

526 #: This error indicates that a device runtime grid launch did not occur 

527 #: because the depth of the child grid would exceed the maximum 

528 #: supported number of nested grid launches. 

529 cudaErrorLaunchMaxDepthExceeded = cyruntime.cudaError.cudaErrorLaunchMaxDepthExceeded 

530  

531 #: This error indicates that a grid launch did not occur because the 

532 #: kernel uses file-scoped textures which are unsupported by the device 

533 #: runtime. Kernels launched via the device runtime only support 

534 #: textures created with the Texture Object API's. 

535 cudaErrorLaunchFileScopedTex = cyruntime.cudaError.cudaErrorLaunchFileScopedTex 

536  

537 #: This error indicates that a grid launch did not occur because the 

538 #: kernel uses file-scoped surfaces which are unsupported by the device 

539 #: runtime. Kernels launched via the device runtime only support 

540 #: surfaces created with the Surface Object API's. 

541 cudaErrorLaunchFileScopedSurf = cyruntime.cudaError.cudaErrorLaunchFileScopedSurf 

542  

543 #: This error indicates that a call to 

544 #: :py:obj:`~.cudaDeviceSynchronize` made from the device runtime 

545 #: failed because the call was made at grid depth greater than than 

546 #: either the default (2 levels of grids) or user specified device 

547 #: limit :py:obj:`~.cudaLimitDevRuntimeSyncDepth`. To be able to 

548 #: synchronize on launched grids at a greater depth successfully, the 

549 #: maximum nested depth at which :py:obj:`~.cudaDeviceSynchronize` will 

550 #: be called must be specified with the 

551 #: :py:obj:`~.cudaLimitDevRuntimeSyncDepth` limit to the 

552 #: :py:obj:`~.cudaDeviceSetLimit` api before the host-side launch of a 

553 #: kernel using the device runtime. Keep in mind that additional levels 

554 #: of sync depth require the runtime to reserve large amounts of device 

555 #: memory that cannot be used for user allocations. Note that 

556 #: :py:obj:`~.cudaDeviceSynchronize` made from device runtime is only 

557 #: supported on devices of compute capability < 9.0. 

558 cudaErrorSyncDepthExceeded = cyruntime.cudaError.cudaErrorSyncDepthExceeded 

559  

560 #: This error indicates that a device runtime grid launch failed 

561 #: because the launch would exceed the limit 

562 #: :py:obj:`~.cudaLimitDevRuntimePendingLaunchCount`. For this launch 

563 #: to proceed successfully, :py:obj:`~.cudaDeviceSetLimit` must be 

564 #: called to set the :py:obj:`~.cudaLimitDevRuntimePendingLaunchCount` 

565 #: to be higher than the upper bound of outstanding launches that can 

566 #: be issued to the device runtime. Keep in mind that raising the limit 

567 #: of pending device runtime launches will require the runtime to 

568 #: reserve device memory that cannot be used for user allocations. 

569 cudaErrorLaunchPendingCountExceeded = cyruntime.cudaError.cudaErrorLaunchPendingCountExceeded 

570  

571 #: The requested device function does not exist or is not compiled for 

572 #: the proper device architecture. 

573 cudaErrorInvalidDeviceFunction = cyruntime.cudaError.cudaErrorInvalidDeviceFunction 

574  

575 #: This indicates that no CUDA-capable devices were detected by the 

576 #: installed CUDA driver. 

577 cudaErrorNoDevice = cyruntime.cudaError.cudaErrorNoDevice 

578  

579 #: This indicates that the device ordinal supplied by the user does not 

580 #: correspond to a valid CUDA device or that the action requested is 

581 #: invalid for the specified device. 

582 cudaErrorInvalidDevice = cyruntime.cudaError.cudaErrorInvalidDevice 

583  

584 #: This indicates that the device doesn't have a valid Grid License. 

585 cudaErrorDeviceNotLicensed = cyruntime.cudaError.cudaErrorDeviceNotLicensed 

586  

587 #: By default, the CUDA runtime may perform a minimal set of self- 

588 #: tests, as well as CUDA driver tests, to establish the validity of 

589 #: both. Introduced in CUDA 11.2, this error return indicates that at 

590 #: least one of these tests has failed and the validity of either the 

591 #: runtime or the driver could not be established. 

592 cudaErrorSoftwareValidityNotEstablished = cyruntime.cudaError.cudaErrorSoftwareValidityNotEstablished 

593  

594 #: This indicates an internal startup failure in the CUDA runtime. 

595 cudaErrorStartupFailure = cyruntime.cudaError.cudaErrorStartupFailure 

596  

597 #: This indicates that the device kernel image is invalid. 

598 cudaErrorInvalidKernelImage = cyruntime.cudaError.cudaErrorInvalidKernelImage 

599  

600 #: This most frequently indicates that there is no context bound to the 

601 #: current thread. This can also be returned if the context passed to 

602 #: an API call is not a valid handle (such as a context that has had 

603 #: :py:obj:`~.cuCtxDestroy()` invoked on it). This can also be returned 

604 #: if a user mixes different API versions (i.e. 3010 context with 3020 

605 #: API calls). See :py:obj:`~.cuCtxGetApiVersion()` for more details. 

606 cudaErrorDeviceUninitialized = cyruntime.cudaError.cudaErrorDeviceUninitialized 

607  

608 #: This indicates that the buffer object could not be mapped. 

609 cudaErrorMapBufferObjectFailed = cyruntime.cudaError.cudaErrorMapBufferObjectFailed 

610  

611 #: This indicates that the buffer object could not be unmapped. 

612 cudaErrorUnmapBufferObjectFailed = cyruntime.cudaError.cudaErrorUnmapBufferObjectFailed 

613  

614 #: This indicates that the specified array is currently mapped and thus 

615 #: cannot be destroyed. 

616 cudaErrorArrayIsMapped = cyruntime.cudaError.cudaErrorArrayIsMapped 

617  

618 #: This indicates that the resource is already mapped. 

619 cudaErrorAlreadyMapped = cyruntime.cudaError.cudaErrorAlreadyMapped 

620  

621 #: This indicates that there is no kernel image available that is 

622 #: suitable for the device. This can occur when a user specifies code 

623 #: generation options for a particular CUDA source file that do not 

624 #: include the corresponding device configuration. 

625 cudaErrorNoKernelImageForDevice = cyruntime.cudaError.cudaErrorNoKernelImageForDevice 

626  

627 #: This indicates that a resource has already been acquired. 

628 cudaErrorAlreadyAcquired = cyruntime.cudaError.cudaErrorAlreadyAcquired 

629  

630 #: This indicates that a resource is not mapped. 

631 cudaErrorNotMapped = cyruntime.cudaError.cudaErrorNotMapped 

632  

633 #: This indicates that a mapped resource is not available for access as 

634 #: an array. 

635 cudaErrorNotMappedAsArray = cyruntime.cudaError.cudaErrorNotMappedAsArray 

636  

637 #: This indicates that a mapped resource is not available for access as 

638 #: a pointer. 

639 cudaErrorNotMappedAsPointer = cyruntime.cudaError.cudaErrorNotMappedAsPointer 

640  

641 #: This indicates that an uncorrectable ECC error was detected during 

642 #: execution. 

643 cudaErrorECCUncorrectable = cyruntime.cudaError.cudaErrorECCUncorrectable 

644  

645 #: This indicates that the :py:obj:`~.cudaLimit` passed to the API call 

646 #: is not supported by the active device. 

647 cudaErrorUnsupportedLimit = cyruntime.cudaError.cudaErrorUnsupportedLimit 

648  

649 #: This indicates that a call tried to access an exclusive-thread 

650 #: device that is already in use by a different thread. 

651 cudaErrorDeviceAlreadyInUse = cyruntime.cudaError.cudaErrorDeviceAlreadyInUse 

652  

653 #: This error indicates that P2P access is not supported across the 

654 #: given devices. 

655 cudaErrorPeerAccessUnsupported = cyruntime.cudaError.cudaErrorPeerAccessUnsupported 

656  

657 #: A PTX compilation failed. The runtime may fall back to compiling PTX 

658 #: if an application does not contain a suitable binary for the current 

659 #: device. 

660 cudaErrorInvalidPtx = cyruntime.cudaError.cudaErrorInvalidPtx 

661  

662 #: This indicates an error with the OpenGL or DirectX context. 

663 cudaErrorInvalidGraphicsContext = cyruntime.cudaError.cudaErrorInvalidGraphicsContext 

664  

665 #: This indicates that an uncorrectable NVLink error was detected 

666 #: during the execution. 

667 cudaErrorNvlinkUncorrectable = cyruntime.cudaError.cudaErrorNvlinkUncorrectable 

668  

669 #: This indicates that the PTX JIT compiler library was not found. The 

670 #: JIT Compiler library is used for PTX compilation. The runtime may 

671 #: fall back to compiling PTX if an application does not contain a 

672 #: suitable binary for the current device. 

673 cudaErrorJitCompilerNotFound = cyruntime.cudaError.cudaErrorJitCompilerNotFound 

674  

675 #: This indicates that the provided PTX was compiled with an 

676 #: unsupported toolchain. The most common reason for this, is the PTX 

677 #: was generated by a compiler newer than what is supported by the CUDA 

678 #: driver and PTX JIT compiler. 

679 cudaErrorUnsupportedPtxVersion = cyruntime.cudaError.cudaErrorUnsupportedPtxVersion 

680  

681 #: This indicates that the JIT compilation was disabled. The JIT 

682 #: compilation compiles PTX. The runtime may fall back to compiling PTX 

683 #: if an application does not contain a suitable binary for the current 

684 #: device. 

685 cudaErrorJitCompilationDisabled = cyruntime.cudaError.cudaErrorJitCompilationDisabled 

686  

687 #: This indicates that the provided execution affinity is not supported 

688 #: by the device. 

689 cudaErrorUnsupportedExecAffinity = cyruntime.cudaError.cudaErrorUnsupportedExecAffinity 

690  

691 #: This indicates that the code to be compiled by the PTX JIT contains 

692 #: unsupported call to cudaDeviceSynchronize. 

693 cudaErrorUnsupportedDevSideSync = cyruntime.cudaError.cudaErrorUnsupportedDevSideSync 

694  

695 #: This indicates that an exception occurred on the device that is now 

696 #: contained by the GPU's error containment capability. Common causes 

697 #: are - a. Certain types of invalid accesses of peer GPU memory over 

698 #: nvlink b. Certain classes of hardware errors This leaves the process 

699 #: in an inconsistent state and any further CUDA work will return the 

700 #: same error. To continue using CUDA, the process must be terminated 

701 #: and relaunched. 

702 cudaErrorContained = cyruntime.cudaError.cudaErrorContained 

703  

704 #: This indicates that the device kernel source is invalid. 

705 cudaErrorInvalidSource = cyruntime.cudaError.cudaErrorInvalidSource 

706  

707 #: This indicates that the file specified was not found. 

708 cudaErrorFileNotFound = cyruntime.cudaError.cudaErrorFileNotFound 

709  

710 #: This indicates that a link to a shared object failed to resolve. 

711 cudaErrorSharedObjectSymbolNotFound = cyruntime.cudaError.cudaErrorSharedObjectSymbolNotFound 

712  

713 #: This indicates that initialization of a shared object failed. 

714 cudaErrorSharedObjectInitFailed = cyruntime.cudaError.cudaErrorSharedObjectInitFailed 

715  

716 #: This error indicates that an OS call failed. 

717 cudaErrorOperatingSystem = cyruntime.cudaError.cudaErrorOperatingSystem 

718  

719 #: This indicates that a resource handle passed to the API call was not 

720 #: valid. Resource handles are opaque types like 

721 #: :py:obj:`~.cudaStream_t` and :py:obj:`~.cudaEvent_t`. 

722 cudaErrorInvalidResourceHandle = cyruntime.cudaError.cudaErrorInvalidResourceHandle 

723  

724 #: This indicates that a resource required by the API call is not in a 

725 #: valid state to perform the requested operation. 

726 cudaErrorIllegalState = cyruntime.cudaError.cudaErrorIllegalState 

727  

728 #: This indicates an attempt was made to introspect an object in a way 

729 #: that would discard semantically important information. This is 

730 #: either due to the object using funtionality newer than the API 

731 #: version used to introspect it or omission of optional return 

732 #: arguments. 

733 cudaErrorLossyQuery = cyruntime.cudaError.cudaErrorLossyQuery 

734  

735 #: This indicates that a named symbol was not found. Examples of 

736 #: symbols are global/constant variable names, driver function names, 

737 #: texture names, and surface names. 

738 cudaErrorSymbolNotFound = cyruntime.cudaError.cudaErrorSymbolNotFound 

739  

740 #: This indicates that asynchronous operations issued previously have 

741 #: not completed yet. This result is not actually an error, but must be 

742 #: indicated differently than :py:obj:`~.cudaSuccess` (which indicates 

743 #: completion). Calls that may return this value include 

744 #: :py:obj:`~.cudaEventQuery()` and :py:obj:`~.cudaStreamQuery()`. 

745 cudaErrorNotReady = cyruntime.cudaError.cudaErrorNotReady 

746  

747 #: The device encountered a load or store instruction on an invalid 

748 #: memory address. This leaves the process in an inconsistent state and 

749 #: any further CUDA work will return the same error. To continue using 

750 #: CUDA, the process must be terminated and relaunched. 

751 cudaErrorIllegalAddress = cyruntime.cudaError.cudaErrorIllegalAddress 

752  

753 #: This indicates that a launch did not occur because it did not have 

754 #: appropriate resources. Although this error is similar to 

755 #: :py:obj:`~.cudaErrorInvalidConfiguration`, this error usually 

756 #: indicates that the user has attempted to pass too many arguments to 

757 #: the device kernel, or the kernel launch specifies too many threads 

758 #: for the kernel's register count. 

759 cudaErrorLaunchOutOfResources = cyruntime.cudaError.cudaErrorLaunchOutOfResources 

760  

761 #: This indicates that the device kernel took too long to execute. This 

762 #: can only occur if timeouts are enabled - see the device attribute 

763 #: :py:obj:`~.cudaDevAttrKernelExecTimeout` for more information. This 

764 #: leaves the process in an inconsistent state and any further CUDA 

765 #: work will return the same error. To continue using CUDA, the process 

766 #: must be terminated and relaunched. 

767 cudaErrorLaunchTimeout = cyruntime.cudaError.cudaErrorLaunchTimeout 

768  

769 #: This error indicates a kernel launch that uses an incompatible 

770 #: texturing mode. 

771 cudaErrorLaunchIncompatibleTexturing = cyruntime.cudaError.cudaErrorLaunchIncompatibleTexturing 

772  

773 #: This error indicates that a call to 

774 #: :py:obj:`~.cudaDeviceEnablePeerAccess()` is trying to re-enable peer 

775 #: addressing on from a context which has already had peer addressing 

776 #: enabled. 

777 cudaErrorPeerAccessAlreadyEnabled = cyruntime.cudaError.cudaErrorPeerAccessAlreadyEnabled 

778  

779 #: This error indicates that :py:obj:`~.cudaDeviceDisablePeerAccess()` 

780 #: is trying to disable peer addressing which has not been enabled yet 

781 #: via :py:obj:`~.cudaDeviceEnablePeerAccess()`. 

782 cudaErrorPeerAccessNotEnabled = cyruntime.cudaError.cudaErrorPeerAccessNotEnabled 

783  

784 #: This indicates that the user has called 

785 #: :py:obj:`~.cudaSetValidDevices()`, :py:obj:`~.cudaSetDeviceFlags()`, 

786 #: :py:obj:`~.cudaD3D9SetDirect3DDevice()`, 

787 #: :py:obj:`~.cudaD3D10SetDirect3DDevice`, 

788 #: :py:obj:`~.cudaD3D11SetDirect3DDevice()`, or 

789 #: :py:obj:`~.cudaVDPAUSetVDPAUDevice()` after initializing the CUDA 

790 #: runtime by calling non-device management operations (allocating 

791 #: memory and launching kernels are examples of non-device management 

792 #: operations). This error can also be returned if using runtime/driver 

793 #: interoperability and there is an existing :py:obj:`~.CUcontext` 

794 #: active on the host thread. 

795 cudaErrorSetOnActiveProcess = cyruntime.cudaError.cudaErrorSetOnActiveProcess 

796  

797 #: This error indicates that the context current to the calling thread 

798 #: has been destroyed using :py:obj:`~.cuCtxDestroy`, or is a primary 

799 #: context which has not yet been initialized. 

800 cudaErrorContextIsDestroyed = cyruntime.cudaError.cudaErrorContextIsDestroyed 

801  

802 #: An assert triggered in device code during kernel execution. The 

803 #: device cannot be used again. All existing allocations are invalid. 

804 #: To continue using CUDA, the process must be terminated and 

805 #: relaunched. 

806 cudaErrorAssert = cyruntime.cudaError.cudaErrorAssert 

807  

808 #: This error indicates that the hardware resources required to enable 

809 #: peer access have been exhausted for one or more of the devices 

810 #: passed to :py:obj:`~.cudaEnablePeerAccess()`. 

811 cudaErrorTooManyPeers = cyruntime.cudaError.cudaErrorTooManyPeers 

812  

813 #: This error indicates that the memory range passed to 

814 #: :py:obj:`~.cudaHostRegister()` has already been registered. 

815 cudaErrorHostMemoryAlreadyRegistered = cyruntime.cudaError.cudaErrorHostMemoryAlreadyRegistered 

816  

817 #: This error indicates that the pointer passed to 

818 #: :py:obj:`~.cudaHostUnregister()` does not correspond to any 

819 #: currently registered memory region. 

820 cudaErrorHostMemoryNotRegistered = cyruntime.cudaError.cudaErrorHostMemoryNotRegistered 

821  

822 #: Device encountered an error in the call stack during kernel 

823 #: execution, possibly due to stack corruption or exceeding the stack 

824 #: size limit. This leaves the process in an inconsistent state and any 

825 #: further CUDA work will return the same error. To continue using 

826 #: CUDA, the process must be terminated and relaunched. 

827 cudaErrorHardwareStackError = cyruntime.cudaError.cudaErrorHardwareStackError 

828  

829 #: The device encountered an illegal instruction during kernel 

830 #: execution This leaves the process in an inconsistent state and any 

831 #: further CUDA work will return the same error. To continue using 

832 #: CUDA, the process must be terminated and relaunched. 

833 cudaErrorIllegalInstruction = cyruntime.cudaError.cudaErrorIllegalInstruction 

834  

835 #: The device encountered a load or store instruction on a memory 

836 #: address which is not aligned. This leaves the process in an 

837 #: inconsistent state and any further CUDA work will return the same 

838 #: error. To continue using CUDA, the process must be terminated and 

839 #: relaunched. 

840 cudaErrorMisalignedAddress = cyruntime.cudaError.cudaErrorMisalignedAddress 

841  

842 #: While executing a kernel, the device encountered an instruction 

843 #: which can only operate on memory locations in certain address spaces 

844 #: (global, shared, or local), but was supplied a memory address not 

845 #: belonging to an allowed address space. This leaves the process in an 

846 #: inconsistent state and any further CUDA work will return the same 

847 #: error. To continue using CUDA, the process must be terminated and 

848 #: relaunched. 

849 cudaErrorInvalidAddressSpace = cyruntime.cudaError.cudaErrorInvalidAddressSpace 

850  

851 #: The device encountered an invalid program counter. This leaves the 

852 #: process in an inconsistent state and any further CUDA work will 

853 #: return the same error. To continue using CUDA, the process must be 

854 #: terminated and relaunched. 

855 cudaErrorInvalidPc = cyruntime.cudaError.cudaErrorInvalidPc 

856  

857 #: An exception occurred on the device while executing a kernel. Common 

858 #: causes include dereferencing an invalid device pointer and accessing 

859 #: out of bounds shared memory. Less common cases can be system 

860 #: specific - more information about these cases can be found in the 

861 #: system specific user guide. This leaves the process in an 

862 #: inconsistent state and any further CUDA work will return the same 

863 #: error. To continue using CUDA, the process must be terminated and 

864 #: relaunched. 

865 cudaErrorLaunchFailure = cyruntime.cudaError.cudaErrorLaunchFailure 

866  

867 #: This error indicates that the number of blocks launched per grid for 

868 #: a kernel that was launched via either 

869 #: :py:obj:`~.cudaLaunchCooperativeKernel` exceeds the maximum number 

870 #: of blocks as allowed by 

871 #: :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessor` or 

872 #: :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags` 

873 #: times the number of multiprocessors as specified by the device 

874 #: attribute :py:obj:`~.cudaDevAttrMultiProcessorCount`. 

875 cudaErrorCooperativeLaunchTooLarge = cyruntime.cudaError.cudaErrorCooperativeLaunchTooLarge 

876  

877 #: An exception occurred on the device while exiting a kernel using 

878 #: tensor memory: the tensor memory was not completely deallocated. 

879 #: This leaves the process in an inconsistent state and any further 

880 #: CUDA work will return the same error. To continue using CUDA, the 

881 #: process must be terminated and relaunched. 

882 cudaErrorTensorMemoryLeak = cyruntime.cudaError.cudaErrorTensorMemoryLeak 

883  

884 #: This error indicates the attempted operation is not permitted. 

885 cudaErrorNotPermitted = cyruntime.cudaError.cudaErrorNotPermitted 

886  

887 #: This error indicates the attempted operation is not supported on the 

888 #: current system or device. 

889 cudaErrorNotSupported = cyruntime.cudaError.cudaErrorNotSupported 

890  

891 #: This error indicates that the system is not yet ready to start any 

892 #: CUDA work. To continue using CUDA, verify the system configuration 

893 #: is in a valid state and all required driver daemons are actively 

894 #: running. More information about this error can be found in the 

895 #: system specific user guide. 

896 cudaErrorSystemNotReady = cyruntime.cudaError.cudaErrorSystemNotReady 

897  

898 #: This error indicates that there is a mismatch between the versions 

899 #: of the display driver and the CUDA driver. Refer to the 

900 #: compatibility documentation for supported versions. 

901 cudaErrorSystemDriverMismatch = cyruntime.cudaError.cudaErrorSystemDriverMismatch 

902  

903 #: This error indicates that the system was upgraded to run with 

904 #: forward compatibility but the visible hardware detected by CUDA does 

905 #: not support this configuration. Refer to the compatibility 

906 #: documentation for the supported hardware matrix or ensure that only 

907 #: supported hardware is visible during initialization via the 

908 #: CUDA_VISIBLE_DEVICES environment variable. 

909 cudaErrorCompatNotSupportedOnDevice = cyruntime.cudaError.cudaErrorCompatNotSupportedOnDevice 

910  

911 #: This error indicates that the MPS client failed to connect to the 

912 #: MPS control daemon or the MPS server. 

913 cudaErrorMpsConnectionFailed = cyruntime.cudaError.cudaErrorMpsConnectionFailed 

914  

915 #: This error indicates that the remote procedural call between the MPS 

916 #: server and the MPS client failed. 

917 cudaErrorMpsRpcFailure = cyruntime.cudaError.cudaErrorMpsRpcFailure 

918  

919 #: This error indicates that the MPS server is not ready to accept new 

920 #: MPS client requests. This error can be returned when the MPS server 

921 #: is in the process of recovering from a fatal failure. 

922 cudaErrorMpsServerNotReady = cyruntime.cudaError.cudaErrorMpsServerNotReady 

923  

924 #: This error indicates that the hardware resources required to create 

925 #: MPS client have been exhausted. 

926 cudaErrorMpsMaxClientsReached = cyruntime.cudaError.cudaErrorMpsMaxClientsReached 

927  

928 #: This error indicates the the hardware resources required to device 

929 #: connections have been exhausted. 

930 cudaErrorMpsMaxConnectionsReached = cyruntime.cudaError.cudaErrorMpsMaxConnectionsReached 

931  

932 #: This error indicates that the MPS client has been terminated by the 

933 #: server. To continue using CUDA, the process must be terminated and 

934 #: relaunched. 

935 cudaErrorMpsClientTerminated = cyruntime.cudaError.cudaErrorMpsClientTerminated 

936  

937 #: This error indicates, that the program is using CUDA Dynamic 

938 #: Parallelism, but the current configuration, like MPS, does not 

939 #: support it. 

940 cudaErrorCdpNotSupported = cyruntime.cudaError.cudaErrorCdpNotSupported 

941  

942 #: This error indicates, that the program contains an unsupported 

943 #: interaction between different versions of CUDA Dynamic Parallelism. 

944 cudaErrorCdpVersionMismatch = cyruntime.cudaError.cudaErrorCdpVersionMismatch 

945  

946 #: The operation is not permitted when the stream is capturing. 

947 cudaErrorStreamCaptureUnsupported = cyruntime.cudaError.cudaErrorStreamCaptureUnsupported 

948  

949 #: The current capture sequence on the stream has been invalidated due 

950 #: to a previous error. 

951 cudaErrorStreamCaptureInvalidated = cyruntime.cudaError.cudaErrorStreamCaptureInvalidated 

952  

953 #: The operation would have resulted in a merge of two independent 

954 #: capture sequences. 

955 cudaErrorStreamCaptureMerge = cyruntime.cudaError.cudaErrorStreamCaptureMerge 

956  

957 #: The capture was not initiated in this stream. 

958 cudaErrorStreamCaptureUnmatched = cyruntime.cudaError.cudaErrorStreamCaptureUnmatched 

959  

960 #: The capture sequence contains a fork that was not joined to the 

961 #: primary stream. 

962 cudaErrorStreamCaptureUnjoined = cyruntime.cudaError.cudaErrorStreamCaptureUnjoined 

963  

964 #: A dependency would have been created which crosses the capture 

965 #: sequence boundary. Only implicit in-stream ordering dependencies are 

966 #: allowed to cross the boundary. 

967 cudaErrorStreamCaptureIsolation = cyruntime.cudaError.cudaErrorStreamCaptureIsolation 

968  

969 #: The operation would have resulted in a disallowed implicit 

970 #: dependency on a current capture sequence from cudaStreamLegacy. 

971 cudaErrorStreamCaptureImplicit = cyruntime.cudaError.cudaErrorStreamCaptureImplicit 

972  

973 #: The operation is not permitted on an event which was last recorded 

974 #: in a capturing stream. 

975 cudaErrorCapturedEvent = cyruntime.cudaError.cudaErrorCapturedEvent 

976  

977 #: A stream capture sequence not initiated with the 

978 #: :py:obj:`~.cudaStreamCaptureModeRelaxed` argument to 

979 #: :py:obj:`~.cudaStreamBeginCapture` was passed to 

980 #: :py:obj:`~.cudaStreamEndCapture` in a different thread. 

981 cudaErrorStreamCaptureWrongThread = cyruntime.cudaError.cudaErrorStreamCaptureWrongThread 

982  

983 #: This indicates that the wait operation has timed out. 

984 cudaErrorTimeout = cyruntime.cudaError.cudaErrorTimeout 

985  

986 #: This error indicates that the graph update was not performed because 

987 #: it included changes which violated constraints specific to 

988 #: instantiated graph update. 

989 cudaErrorGraphExecUpdateFailure = cyruntime.cudaError.cudaErrorGraphExecUpdateFailure 

990  

991 #: This indicates that an async error has occurred in a device outside 

992 #: of CUDA. If CUDA was waiting for an external device's signal before 

993 #: consuming shared data, the external device signaled an error 

994 #: indicating that the data is not valid for consumption. This leaves 

995 #: the process in an inconsistent state and any further CUDA work will 

996 #: return the same error. To continue using CUDA, the process must be 

997 #: terminated and relaunched. 

998 cudaErrorExternalDevice = cyruntime.cudaError.cudaErrorExternalDevice 

999  

1000 #: This indicates that a kernel launch error has occurred due to 

1001 #: cluster misconfiguration. 

1002 cudaErrorInvalidClusterSize = cyruntime.cudaError.cudaErrorInvalidClusterSize 

1003  

1004 #: Indiciates a function handle is not loaded when calling an API that 

1005 #: requires a loaded function. 

1006 cudaErrorFunctionNotLoaded = cyruntime.cudaError.cudaErrorFunctionNotLoaded 

1007  

1008 #: This error indicates one or more resources passed in are not valid 

1009 #: resource types for the operation. 

1010 cudaErrorInvalidResourceType = cyruntime.cudaError.cudaErrorInvalidResourceType 

1011  

1012 #: This error indicates one or more resources are insufficient or non- 

1013 #: applicable for the operation. 

1014 cudaErrorInvalidResourceConfiguration = cyruntime.cudaError.cudaErrorInvalidResourceConfiguration 

1015  

1016 #: This error indicates that the requested operation is not permitted 

1017 #: because the stream is in a detached state. This can occur if the 

1018 #: green context associated with the stream has been destroyed, 

1019 #: limiting the stream's operational capabilities. 

1020 cudaErrorStreamDetached = cyruntime.cudaError.cudaErrorStreamDetached 

1021  

1022 #: This indicates that an unknown internal error has occurred. 

1023 cudaErrorUnknown = cyruntime.cudaError.cudaErrorUnknown 

1024 cudaErrorApiFailureBase = cyruntime.cudaError.cudaErrorApiFailureBase 

1025  

1026_dict_cudaError_t = dict(((int(v), v) for k, v in cudaError_t.__members__.items())) 

1027  

1028class cudaGraphDependencyType(IntEnum): 

1029 """ 

1030 Type annotations that can be applied to graph edges as part of 

1031 :py:obj:`~.cudaGraphEdgeData`. 

1032 """ 

1033  

1034 #: This is an ordinary dependency. 

1035 cudaGraphDependencyTypeDefault = cyruntime.cudaGraphDependencyType_enum.cudaGraphDependencyTypeDefault 

1036  

1037 #: This dependency type allows the downstream node to use 

1038 #: `cudaGridDependencySynchronize()`. It may only be used between 

1039 #: kernel nodes, and must be used with either the 

1040 #: :py:obj:`~.cudaGraphKernelNodePortProgrammatic` or 

1041 #: :py:obj:`~.cudaGraphKernelNodePortLaunchCompletion` outgoing port. 

1042 cudaGraphDependencyTypeProgrammatic = cyruntime.cudaGraphDependencyType_enum.cudaGraphDependencyTypeProgrammatic 

1043  

1044_dict_cudaGraphDependencyType = dict(((int(v), v) for k, v in cudaGraphDependencyType.__members__.items())) 

1045  

1046class cudaGraphInstantiateResult(IntEnum): 

1047 """ 

1048 Graph instantiation results 

1049 """ 

1050  

1051 #: Instantiation succeeded 

1052 cudaGraphInstantiateSuccess = cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateSuccess 

1053  

1054 #: Instantiation failed for an unexpected reason which is described in 

1055 #: the return value of the function 

1056 cudaGraphInstantiateError = cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateError 

1057  

1058 #: Instantiation failed due to invalid structure, such as cycles 

1059 cudaGraphInstantiateInvalidStructure = cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateInvalidStructure 

1060  

1061 #: Instantiation for device launch failed because the graph contained 

1062 #: an unsupported operation 

1063 cudaGraphInstantiateNodeOperationNotSupported = cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateNodeOperationNotSupported 

1064  

1065 #: Instantiation for device launch failed due to the nodes belonging to 

1066 #: different contexts 

1067 cudaGraphInstantiateMultipleDevicesNotSupported = cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateMultipleDevicesNotSupported 

1068  

1069 #: One or more conditional handles are not associated with conditional 

1070 #: nodes 

1071 cudaGraphInstantiateConditionalHandleUnused = cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateConditionalHandleUnused 

1072  

1073_dict_cudaGraphInstantiateResult = dict(((int(v), v) for k, v in cudaGraphInstantiateResult.__members__.items())) 

1074  

1075class cudaLaunchMemSyncDomain(IntEnum): 

1076 """ 

1077 Memory Synchronization Domain A kernel can be launched in a 

1078 specified memory synchronization domain that affects all memory 

1079 operations issued by that kernel. A memory barrier issued in one 

1080 domain will only order memory operations in that domain, thus 

1081 eliminating latency increase from memory barriers ordering 

1082 unrelated traffic. By default, kernels are launched in domain 0. 

1083 Kernel launched with :py:obj:`~.cudaLaunchMemSyncDomainRemote` will 

1084 have a different domain ID. User may also alter the domain ID with 

1085 :py:obj:`~.cudaLaunchMemSyncDomainMap` for a specific stream / 

1086 graph node / kernel launch. See 

1087 :py:obj:`~.cudaLaunchAttributeMemSyncDomain`, 

1088 :py:obj:`~.cudaStreamSetAttribute`, :py:obj:`~.cudaLaunchKernelEx`, 

1089 :py:obj:`~.cudaGraphKernelNodeSetAttribute`. Memory operations 

1090 done in kernels launched in different domains are considered 

1091 system-scope distanced. In other words, a GPU scoped memory 

1092 synchronization is not sufficient for memory order to be observed 

1093 by kernels in another memory synchronization domain even if they 

1094 are on the same GPU. 

1095 """ 

1096  

1097 #: Launch kernels in the default domain 

1098 cudaLaunchMemSyncDomainDefault = cyruntime.cudaLaunchMemSyncDomain.cudaLaunchMemSyncDomainDefault 

1099  

1100 #: Launch kernels in the remote domain 

1101 cudaLaunchMemSyncDomainRemote = cyruntime.cudaLaunchMemSyncDomain.cudaLaunchMemSyncDomainRemote 

1102  

1103_dict_cudaLaunchMemSyncDomain = dict(((int(v), v) for k, v in cudaLaunchMemSyncDomain.__members__.items())) 

1104  

1105class cudaLaunchAttributeID(IntEnum): 

1106 """ 

1107 Launch attributes enum; used as id field of 

1108 :py:obj:`~.cudaLaunchAttribute` 

1109 """ 

1110  

1111 #: Ignored entry, for convenient composition 

1112 cudaLaunchAttributeIgnore = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeIgnore 

1113  

1114 #: Valid for streams, graph nodes, launches. See 

1115 #: :py:obj:`~.cudaLaunchAttributeValue.accessPolicyWindow`. 

1116 cudaLaunchAttributeAccessPolicyWindow = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow 

1117  

1118 #: Valid for graph nodes, launches. See 

1119 #: :py:obj:`~.cudaLaunchAttributeValue.cooperative`. 

1120 cudaLaunchAttributeCooperative = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeCooperative 

1121  

1122 #: Valid for streams. See 

1123 #: :py:obj:`~.cudaLaunchAttributeValue.syncPolicy`. 

1124 cudaLaunchAttributeSynchronizationPolicy = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy 

1125  

1126 #: Valid for graph nodes, launches. See 

1127 #: :py:obj:`~.cudaLaunchAttributeValue.clusterDim`. 

1128 cudaLaunchAttributeClusterDimension = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension 

1129  

1130 #: Valid for graph nodes, launches. See 

1131 #: :py:obj:`~.cudaLaunchAttributeValue.clusterSchedulingPolicyPreference`. 

1132 cudaLaunchAttributeClusterSchedulingPolicyPreference = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference 

1133  

1134 #: Valid for launches. Setting 

1135 #: :py:obj:`~.cudaLaunchAttributeValue.programmaticStreamSerializationAllowed` 

1136 #: to non-0 signals that the kernel will use programmatic means to 

1137 #: resolve its stream dependency, so that the CUDA runtime should 

1138 #: opportunistically allow the grid's execution to overlap with the 

1139 #: previous kernel in the stream, if that kernel requests the overlap. 

1140 #: The dependent launches can choose to wait on the dependency using 

1141 #: the programmatic sync (cudaGridDependencySynchronize() or equivalent 

1142 #: PTX instructions). 

1143 cudaLaunchAttributeProgrammaticStreamSerialization = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization 

1144  

1145 #: Valid for launches. Set 

1146 #: :py:obj:`~.cudaLaunchAttributeValue.programmaticEvent` to record the 

1147 #: event. Event recorded through this launch attribute is guaranteed to 

1148 #: only trigger after all block in the associated kernel trigger the 

1149 #: event. A block can trigger the event programmatically in a future 

1150 #: CUDA release. A trigger can also be inserted at the beginning of 

1151 #: each block's execution if triggerAtBlockStart is set to non-0. The 

1152 #: dependent launches can choose to wait on the dependency using the 

1153 #: programmatic sync (cudaGridDependencySynchronize() or equivalent PTX 

1154 #: instructions). Note that dependents (including the CPU thread 

1155 #: calling :py:obj:`~.cudaEventSynchronize()`) are not guaranteed to 

1156 #: observe the release precisely when it is released. For example, 

1157 #: :py:obj:`~.cudaEventSynchronize()` may only observe the event 

1158 #: trigger long after the associated kernel has completed. This 

1159 #: recording type is primarily meant for establishing programmatic 

1160 #: dependency between device tasks. Note also this type of dependency 

1161 #: allows, but does not guarantee, concurrent execution of tasks. 

1162 #: The event supplied must not be an interprocess or interop event. 

1163 #: The event must disable timing (i.e. must be created with the 

1164 #: :py:obj:`~.cudaEventDisableTiming` flag set). 

1165 cudaLaunchAttributeProgrammaticEvent = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent 

1166  

1167 #: Valid for streams, graph nodes, launches. See 

1168 #: :py:obj:`~.cudaLaunchAttributeValue.priority`. 

1169 cudaLaunchAttributePriority = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePriority 

1170  

1171 #: Valid for streams, graph nodes, launches. See 

1172 #: :py:obj:`~.cudaLaunchAttributeValue.memSyncDomainMap`. 

1173 cudaLaunchAttributeMemSyncDomainMap = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeMemSyncDomainMap 

1174  

1175 #: Valid for streams, graph nodes, launches. See 

1176 #: :py:obj:`~.cudaLaunchAttributeValue.memSyncDomain`. 

1177 cudaLaunchAttributeMemSyncDomain = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeMemSyncDomain 

1178  

1179 #: Valid for graph nodes and launches. Set 

1180 #: :py:obj:`~.cudaLaunchAttributeValue.preferredClusterDim` to allow 

1181 #: the kernel launch to specify a preferred substitute cluster 

1182 #: dimension. Blocks may be grouped according to either the dimensions 

1183 #: specified with this attribute (grouped into a "preferred substitute 

1184 #: cluster"), or the one specified with 

1185 #: :py:obj:`~.cudaLaunchAttributeClusterDimension` attribute (grouped 

1186 #: into a "regular cluster"). The cluster dimensions of a "preferred 

1187 #: substitute cluster" shall be an integer multiple greater than zero 

1188 #: of the regular cluster dimensions. The device will attempt - on a 

1189 #: best-effort basis - to group thread blocks into preferred clusters 

1190 #: over grouping them into regular clusters. When it deems necessary 

1191 #: (primarily when the device temporarily runs out of physical 

1192 #: resources to launch the larger preferred clusters), the device may 

1193 #: switch to launch the regular clusters instead to attempt to utilize 

1194 #: as much of the physical device resources as possible. 

1195 #: Each type of cluster will have its enumeration / coordinate setup 

1196 #: as if the grid consists solely of its type of cluster. For example, 

1197 #: if the preferred substitute cluster dimensions double the regular 

1198 #: cluster dimensions, there might be simultaneously a regular cluster 

1199 #: indexed at (1,0,0), and a preferred cluster indexed at (1,0,0). In 

1200 #: this example, the preferred substitute cluster (1,0,0) replaces 

1201 #: regular clusters (2,0,0) and (3,0,0) and groups their blocks. 

1202 #: This attribute will only take effect when a regular cluster 

1203 #: dimension has been specified. The preferred substitute cluster 

1204 #: dimension must be an integer multiple greater than zero of the 

1205 #: regular cluster dimension and must divide the grid. It must also be 

1206 #: no more than `maxBlocksPerCluster`, if it is set in the kernel's 

1207 #: `__launch_bounds__`. Otherwise it must be less than the maximum 

1208 #: value the driver can support. Otherwise, setting this attribute to a 

1209 #: value physically unable to fit on any particular device is 

1210 #: permitted. 

1211 cudaLaunchAttributePreferredClusterDimension = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredClusterDimension 

1212  

1213 #: Valid for launches. Set 

1214 #: :py:obj:`~.cudaLaunchAttributeValue.launchCompletionEvent` to record 

1215 #: the event. 

1216 #: Nominally, the event is triggered once all blocks of the kernel 

1217 #: have begun execution. Currently this is a best effort. If a kernel B 

1218 #: has a launch completion dependency on a kernel A, B may wait until A 

1219 #: is complete. Alternatively, blocks of B may begin before all blocks 

1220 #: of A have begun, for example if B can claim execution resources 

1221 #: unavailable to A (e.g. they run on different GPUs) or if B is a 

1222 #: higher priority than A. Exercise caution if such an ordering 

1223 #: inversion could lead to deadlock. 

1224 #: A launch completion event is nominally similar to a programmatic 

1225 #: event with `triggerAtBlockStart` set except that it is not visible 

1226 #: to `cudaGridDependencySynchronize()` and can be used with compute 

1227 #: capability less than 9.0. 

1228 #: The event supplied must not be an interprocess or interop event. 

1229 #: The event must disable timing (i.e. must be created with the 

1230 #: :py:obj:`~.cudaEventDisableTiming` flag set). 

1231 cudaLaunchAttributeLaunchCompletionEvent = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeLaunchCompletionEvent 

1232  

1233 #: Valid for graph nodes, launches. This attribute is graphs-only, and 

1234 #: passing it to a launch in a non-capturing stream will result in an 

1235 #: error. 

1236 #: :cudaLaunchAttributeValue::deviceUpdatableKernelNode::deviceUpdatable 

1237 #: can only be set to 0 or 1. Setting the field to 1 indicates that the 

1238 #: corresponding kernel node should be device-updatable. On success, a 

1239 #: handle will be returned via 

1240 #: :py:obj:`~.cudaLaunchAttributeValue`::deviceUpdatableKernelNode::devNode 

1241 #: which can be passed to the various device-side update functions to 

1242 #: update the node's kernel parameters from within another kernel. For 

1243 #: more information on the types of device updates that can be made, as 

1244 #: well as the relevant limitations thereof, see 

1245 #: :py:obj:`~.cudaGraphKernelNodeUpdatesApply`. 

1246 #: Nodes which are device-updatable have additional restrictions 

1247 #: compared to regular kernel nodes. Firstly, device-updatable nodes 

1248 #: cannot be removed from their graph via 

1249 #: :py:obj:`~.cudaGraphDestroyNode`. Additionally, once opted-in to 

1250 #: this functionality, a node cannot opt out, and any attempt to set 

1251 #: the deviceUpdatable attribute to 0 will result in an error. Device- 

1252 #: updatable kernel nodes also cannot have their attributes copied 

1253 #: to/from another kernel node via 

1254 #: :py:obj:`~.cudaGraphKernelNodeCopyAttributes`. Graphs containing one 

1255 #: or more device-updatable nodes also do not allow multiple 

1256 #: instantiation, and neither the graph nor its instantiated version 

1257 #: can be passed to :py:obj:`~.cudaGraphExecUpdate`. 

1258 #: If a graph contains device-updatable nodes and updates those nodes 

1259 #: from the device from within the graph, the graph must be uploaded 

1260 #: with :py:obj:`~.cuGraphUpload` before it is launched. For such a 

1261 #: graph, if host-side executable graph updates are made to the device- 

1262 #: updatable nodes, the graph must be uploaded before it is launched 

1263 #: again. 

1264 cudaLaunchAttributeDeviceUpdatableKernelNode = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeDeviceUpdatableKernelNode 

1265  

1266 #: Valid for launches. On devices where the L1 cache and shared memory 

1267 #: use the same hardware resources, setting 

1268 #: :py:obj:`~.cudaLaunchAttributeValue.sharedMemCarveout` to a 

1269 #: percentage between 0-100 signals sets the shared memory carveout 

1270 #: preference in percent of the total shared memory for that kernel 

1271 #: launch. This attribute takes precedence over 

1272 #: :py:obj:`~.cudaFuncAttributePreferredSharedMemoryCarveout`. This is 

1273 #: only a hint, and the driver can choose a different configuration if 

1274 #: required for the launch. 

1275 cudaLaunchAttributePreferredSharedMemoryCarveout = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredSharedMemoryCarveout 

1276  

1277 #: Valid for streams, graph nodes, launches. This attribute is a hint 

1278 #: to the CUDA runtime that the launch should attempt to make the 

1279 #: kernel maximize its NVLINK utilization. 

1280 #: 

1281 #: When possible to honor this hint, CUDA will assume each block in 

1282 #: the grid launch will carry out an even amount of NVLINK traffic, and 

1283 #: make a best-effort attempt to adjust the kernel launch based on that 

1284 #: assumption. 

1285 #: This attribute is a hint only. CUDA makes no functional or 

1286 #: performance guarantee. Its applicability can be affected by many 

1287 #: different factors, including driver version (i.e. CUDA doesn't 

1288 #: guarantee the performance characteristics will be maintained between 

1289 #: driver versions or a driver update could alter or regress previously 

1290 #: observed perf characteristics.) It also doesn't guarantee a 

1291 #: successful result, i.e. applying the attribute may not improve the 

1292 #: performance of either the targeted kernel or the encapsulating 

1293 #: application. 

1294 #: Valid values for 

1295 #: :py:obj:`~.cudaLaunchAttributeValue.nvlinkUtilCentricScheduling` are 

1296 #: 0 (disabled) and 1 (enabled). 

1297 cudaLaunchAttributeNvlinkUtilCentricScheduling = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeNvlinkUtilCentricScheduling 

1298  

1299_dict_cudaLaunchAttributeID = dict(((int(v), v) for k, v in cudaLaunchAttributeID.__members__.items())) 

1300  

1301class cudaAsyncNotificationType(IntEnum): 

1302 """ 

1303 Types of async notification that can occur 

1304 """ 

1305  

1306 #: Sent when the process has exceeded its device memory budget 

1307 cudaAsyncNotificationTypeOverBudget = cyruntime.cudaAsyncNotificationType_enum.cudaAsyncNotificationTypeOverBudget 

1308  

1309_dict_cudaAsyncNotificationType = dict(((int(v), v) for k, v in cudaAsyncNotificationType.__members__.items())) 

1310  

1311class cudaLogLevel(IntEnum): 

1312 """ 

1313  

1314 """ 

1315 cudaLogLevelError = cyruntime.CUDAlogLevel_enum.cudaLogLevelError 

1316 cudaLogLevelWarning = cyruntime.CUDAlogLevel_enum.cudaLogLevelWarning 

1317  

1318_dict_cudaLogLevel = dict(((int(v), v) for k, v in cudaLogLevel.__members__.items())) 

1319  

1320class cudaDataType(IntEnum): 

1321 """""" 

1322 CUDA_R_32F = cyruntime.cudaDataType_t.CUDA_R_32F 

1323 CUDA_R_64F = cyruntime.cudaDataType_t.CUDA_R_64F 

1324 CUDA_R_16F = cyruntime.cudaDataType_t.CUDA_R_16F 

1325 CUDA_R_8I = cyruntime.cudaDataType_t.CUDA_R_8I 

1326 CUDA_C_32F = cyruntime.cudaDataType_t.CUDA_C_32F 

1327 CUDA_C_64F = cyruntime.cudaDataType_t.CUDA_C_64F 

1328 CUDA_C_16F = cyruntime.cudaDataType_t.CUDA_C_16F 

1329 CUDA_C_8I = cyruntime.cudaDataType_t.CUDA_C_8I 

1330 CUDA_R_8U = cyruntime.cudaDataType_t.CUDA_R_8U 

1331 CUDA_C_8U = cyruntime.cudaDataType_t.CUDA_C_8U 

1332 CUDA_R_32I = cyruntime.cudaDataType_t.CUDA_R_32I 

1333 CUDA_C_32I = cyruntime.cudaDataType_t.CUDA_C_32I 

1334 CUDA_R_32U = cyruntime.cudaDataType_t.CUDA_R_32U