6.1. 设备管理

本节介绍 CUDA 运行时应用程序编程接口的设备管理功能。

函数

__host__ ​cudaError_t cudaChooseDevice ( int* device, const cudaDeviceProp* prop )
选择最符合条件的计算设备。
__host__ ​cudaError_t cudaDeviceFlushGPUDirectRDMAWrites ( cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope )
阻塞直到远程写入对指定的范围可见。
__host__ ​ __device__ ​cudaError_t cudaDeviceGetAttribute ( int* value, cudaDeviceAttr attr, int  device )
返回有关设备的信息。
__host__ ​cudaError_t cudaDeviceGetByPCIBusId ( int* device, const char* pciBusId )
返回计算设备的句柄。
__host__ ​ __device__ ​cudaError_t cudaDeviceGetCacheConfig ( cudaFuncCache* pCacheConfig )
返回当前设备的首选缓存配置。
__host__ ​cudaError_t cudaDeviceGetDefaultMemPool ( cudaMemPool_t* memPool, int  device )
返回设备的默认内存池。
__host__ ​ __device__ ​cudaError_t cudaDeviceGetLimit ( size_t* pValue, cudaLimit limit )
返回资源限制。
__host__ ​cudaError_t cudaDeviceGetMemPool ( cudaMemPool_t* memPool, int  device )
获取设备的当前内存池。
__host__ ​cudaError_t cudaDeviceGetNvSciSyncAttributes ( void* nvSciSyncAttrList, int  device, int  flags )
返回此设备可以支持的 NvSciSync 属性。
__host__ ​cudaError_t cudaDeviceGetP2PAttribute ( int* value, cudaDeviceP2PAttr attr, int  srcDevice, int  dstDevice )
查询两个设备之间链接的属性。
__host__ ​cudaError_t cudaDeviceGetPCIBusId ( char* pciBusId, int  len, int  device )
返回设备的 PCI 总线 ID 字符串。
__host__ ​cudaError_t cudaDeviceGetStreamPriorityRange ( int* leastPriority, int* greatestPriority )
返回对应于最小和最大流优先级的数值。
__host__ ​cudaError_t cudaDeviceGetTexture1DLinearMaxWidth ( size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int  device )
返回给定元素大小的 1D 线性纹理中可分配的最大元素数。
__host__ ​cudaError_t cudaDeviceRegisterAsyncNotification ( int  device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback )
注册回调函数以接收异步通知。
__host__ ​cudaError_t cudaDeviceReset ( void )
销毁当前进程中当前设备上的所有分配并重置所有状态。
__host__ ​cudaError_t cudaDeviceSetCacheConfig ( cudaFuncCache* cacheConfig )
设置当前设备的首选缓存配置。
__host__ ​cudaError_t cudaDeviceSetLimit ( cudaLimit limit, size_t value )
设置资源限制。
__host__ ​cudaError_t cudaDeviceSetMemPool ( int  device, cudaMemPool_t memPool )
设置设备的当前内存池。
__host__ ​ __device__ ​cudaError_t cudaDeviceSynchronize ( void )
等待计算设备完成。
__host__ ​cudaError_t cudaDeviceUnregisterAsyncNotification ( int  device, cudaAsyncCallbackHandle_t callback )
取消注册异步通知回调。
__host__ ​ __device__ ​cudaError_t cudaGetDevice ( int* device )
返回当前正在使用的设备。
__host__ ​ __device__ ​cudaError_t cudaGetDeviceCount ( int* count )
返回具有计算能力的设备数量。
__host__ ​cudaError_t cudaGetDeviceFlags ( unsigned int* flags )
获取当前设备的标志。
__host__ ​cudaError_t cudaGetDeviceProperties ( cudaDeviceProp* prop, int  device )
返回有关计算设备的信息。
__host__ ​cudaError_t cudaInitDevice ( int  device, unsigned int  deviceFlags, unsigned int  flags )
初始化设备以用于 GPU 执行。
__host__ ​cudaError_t cudaIpcCloseMemHandle ( void* devPtr )
尝试关闭使用 cudaIpcOpenMemHandle 映射的内存。
__host__ ​cudaError_t cudaIpcGetEventHandle ( cudaIpcEventHandle_t* handle, cudaEvent_t event )
获取先前分配事件的进程间句柄。
__host__ ​cudaError_t cudaIpcGetMemHandle ( cudaIpcMemHandle_t* handle, void* devPtr )
获取现有设备内存分配的进程间内存句柄。
__host__ ​cudaError_t cudaIpcOpenEventHandle ( cudaEvent_t* event, cudaIpcEventHandle_t handle )
打开进程间事件句柄以在当前进程中使用。
__host__ ​cudaError_t cudaIpcOpenMemHandle ( void** devPtr, cudaIpcMemHandle_t handle, unsigned int  flags )
打开从另一个进程导出的进程间内存句柄，并返回可在本地进程中使用的设备指针。
__host__ ​cudaError_t cudaSetDevice ( int  device )
设置用于 GPU 执行的设备。
__host__ ​cudaError_t cudaSetDeviceFlags ( unsigned int  flags )
设置用于设备执行的标志。
__host__ ​cudaError_t cudaSetValidDevices ( int* device_arr, int  len )
设置可用于 CUDA 的设备列表。

函数

__host__ ​cudaError_t cudaChooseDevice ( int* device, const cudaDeviceProp* prop )
选择最符合条件的计算设备。
参数
device
- 最佳匹配的设备
prop
- 所需的设备属性
返回值

cudaSuccess, cudaErrorInvalidValue

描述

在*device中返回具有最匹配*prop.

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

另请参阅

__host__ ​cudaError_t cudaDeviceFlushGPUDirectRDMAWrites ( cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope )
阻塞直到远程写入对指定的范围可见。
参数
target
- 操作的目标，请参阅 cudaFlushGPUDirectRDMAWritesTarget
scope
- 操作的范围，请参阅 cudaFlushGPUDirectRDMAWritesScope
返回值

cudaSuccess, cudaErrorNotSupported,

描述

阻塞直到通过 GPUDirect RDMA API（如 nvidia_p2p_get_pages（有关详细信息，请参阅 https://docs.nvda.net.cn/cuda/gpudirect-rdma））创建的映射对目标上下文的远程写入对指定的范围可见。

如果范围等于或位于 cudaDevAttrGPUDirectRDMAWritesOrdering 指示的范围内，则调用将是空操作，并且为了性能可以安全地省略。 这可以通过比较两个枚举之间的数值来确定，较小的范围具有较小的值。

用户可以通过 cudaDevAttrGPUDirectRDMAFlushWritesOptions 查询对此 API 的支持。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cuFlushGPUDirectRDMAWrites

__host__ ​ __device__ ​cudaError_t cudaDeviceGetAttribute ( int* value, cudaDeviceAttr attr, int  device )
返回有关设备的信息。
参数
value
- 返回的设备属性值
attr
- 要查询的设备属性
device
- 要查询的设备号
返回值

cudaSuccess, cudaErrorInvalidDevice, cudaErrorInvalidValue

描述

在*value属性的整数值attr在设备上device。 支持的属性包括

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDeviceCount, cudaGetDevice, cudaSetDevice, cudaChooseDevice, cudaGetDeviceProperties, cudaInitDevice, cuDeviceGetAttribute

__host__ ​cudaError_t cudaDeviceGetByPCIBusId ( int* device, const char* pciBusId )
返回计算设备的句柄。
参数
device
- 返回的设备序号
pciBusId
- 以下列形式之一的字符串：[域]:[总线]:[设备].[功能] [域]:[总线]:[设备] [总线]:[设备].[功能]，其中域, 总线, device，以及功能均为十六进制值
返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

在*device给定 PCI 总线 ID 字符串的设备序号。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceGetPCIBusId, cuDeviceGetByPCIBusId

__host__ ​ __device__ ​cudaError_t cudaDeviceGetCacheConfig ( cudaFuncCache* pCacheConfig )
返回当前设备的首选缓存配置。
参数
pCacheConfig
- 返回的缓存配置
返回值

cudaSuccess

描述

在 L1 缓存和共享内存使用相同硬件资源的设备上，这将通过pCacheConfig返回当前设备的首选缓存配置。这只是一种偏好。运行时将尽可能使用请求的配置，但如果需要执行函数，则可以自由选择不同的配置。

这将返回pCacheConfigcudaFuncCachePreferNone 在 L1 缓存和共享内存大小固定的设备上。

支持的缓存配置为

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceSetCacheConfig, cudaFuncSetCacheConfig ( C API), cudaFuncSetCacheConfig ( C++ API), cuCtxGetCacheConfig

__host__ ​cudaError_t cudaDeviceGetDefaultMemPool ( cudaMemPool_t* memPool, int  device )
返回设备的默认内存池。
返回值

cudaSuccess, cudaErrorInvalidDevice, cudaErrorInvalidValuecudaErrorNotSupported

描述

设备的默认内存池包含来自该设备的设备内存。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cuDeviceGetDefaultMemPool, cudaMallocAsync, cudaMemPoolTrimTo, cudaMemPoolGetAttribute, cudaDeviceSetMemPool, cudaMemPoolSetAttribute, cudaMemPoolSetAccess

__host__ ​ __device__ ​cudaError_t cudaDeviceGetLimit ( size_t* pValue, cudaLimit limit )
返回资源限制。
参数
pValue
- 返回的限制大小
limit
- 要查询的限制
返回值

cudaSuccess, cudaErrorUnsupportedLimit, cudaErrorInvalidValue

描述

在*pValue的大小limit。支持以下 cudaLimit 值。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceSetLimit, cuCtxGetLimit

__host__ ​cudaError_t cudaDeviceGetMemPool ( cudaMemPool_t* memPool, int  device )
获取设备的当前内存池。
返回值

cudaSuccess, cudaErrorInvalidValuecudaErrorNotSupported

描述

返回上次为此设备调用 cudaDeviceSetMemPool 时提供的池，或者如果从未调用 cudaDeviceSetMemPool，则返回设备的默认内存池。默认情况下，当前内存池是设备的默认内存池，否则返回的池必须已通过 cuDeviceSetMemPool 或 cudaDeviceSetMemPool 设置。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cuDeviceGetMemPool, cudaDeviceGetDefaultMemPool, cudaDeviceSetMemPool

__host__ ​cudaError_t cudaDeviceGetNvSciSyncAttributes ( void* nvSciSyncAttrList, int  device, int  flags )
返回此设备可以支持的 NvSciSync 属性。
参数
nvSciSyncAttrList
- 返回支持的 NvSciSync 属性。
device
- 有效的 Cuda 设备，用于获取 NvSciSync 属性。
flags
- 描述 NvSciSync 用法的标志。
描述

在nvSciSyncAttrList，此 CUDA 设备 NvSciSync 的属性，dev可以支持。返回的nvSciSyncAttrList可用于创建与此设备功能匹配的 NvSciSync。

如果nvSciSyncAttrList中已设置 NvSciSyncAttrKey_RequiredPerm 字段，则此 API 将返回 cudaErrorInvalidValue。

应用程序应将nvSciSyncAttrList设置为有效的 NvSciSyncAttrList，否则此 API 将返回 cudaErrorInvalidHandle。

的flags控制应用程序如何使用从nvSciSyncAttrList创建的 NvSciSync。有效标志为

必须至少设置其中一个标志，否则 API 将返回 cudaErrorInvalidValue。这两个标志彼此正交：开发人员可以同时设置这两个标志，以便在同一nvSciSyncAttrList.

中设置等待和信号特定属性nvSciSyncAttrList注意，此 API 使用等效于以下公共属性键值的值更新输入

是 GA10X+，则为 NvSciSyncAttrValPrimitiveType_SysmemSemaphorePayload64b。NvSciSyncAttrKey_GpuId 设置为在

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceProp.uuid

中返回的相同 UUID，来自此
cudaSuccess, cudaErrorDeviceUninitialized, cudaErrorInvalidValue, cudaErrorInvalidHandle, cudaErrorInvalidDevice, cudaErrorNotSupported, cudaErrorMemoryAllocation
参数
value
cudaImportExternalSemaphore, cudaDestroyExternalSemaphore, cudaSignalExternalSemaphoresAsync, cudaWaitExternalSemaphoresAsync
attr
__host__ ​cudaError_t cudaDeviceGetP2PAttribute ( int* value, cudaDeviceP2PAttr attr, int  srcDevice, int  dstDevice )
查询两个设备之间链接的属性。
dstDevice
- 目标链接的目标设备。
返回值

cudaSuccess, cudaErrorInvalidDevice, cudaErrorInvalidValue

描述

在*value请求属性的值attrib在以下设备之间的链接的 __host__ ​cudaError_t cudaDeviceGetP2PAttribute ( int* value, cudaDeviceP2PAttr attr, int  srcDevice, int  dstDevice ) 和dstDevice。 支持的属性包括

如果以下情况，则返回 cudaErrorInvalidDevice __host__ ​cudaError_t cudaDeviceGetP2PAttribute ( int* value, cudaDeviceP2PAttr attr, int  srcDevice, int  dstDevice ) 或dstDevice无效，或者它们代表同一设备。

如果以下情况，则返回 cudaErrorInvalidValueattrib无效，或者如果value是空指针。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceEnablePeerAccess, cudaDeviceDisablePeerAccess, cudaDeviceCanAccessPeer, cuDeviceGetP2PAttribute

__host__ ​cudaError_t cudaDeviceGetPCIBusId ( char* pciBusId, int  len, int  device )
返回设备的 PCI 总线 ID 字符串。
参数
pciBusId
- 返回的设备标识符字符串，格式如下：[域]:[总线]:[设备].[功能]，其中域, 总线, device，以及功能均为十六进制值。pciBusId 应足够大，以存储 13 个字符，包括 NULL 终止符。
len
- 要存储在以下位置的字符串的最大长度name
device
- 获取标识符字符串的设备
返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

返回一个 ASCII 字符串，用于标识设备dev在指向的 NULL 终止字符串中pciBusId. len指定可能返回的字符串的最大长度。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceGetByPCIBusId, cuDeviceGetPCIBusId

__host__ ​cudaError_t cudaDeviceGetStreamPriorityRange ( int* leastPriority, int* greatestPriority )
返回与最小和最大流优先级对应的数值。
参数
leastPriority
- 指向 int 的指针，其中返回最小流优先级的数值
greatestPriority
- 指向 int 的指针，其中返回最大流优先级的数值
返回值

cudaSuccess

描述

在*leastPriority和*greatestPriority分别对应于最小和最大流优先级的数值。流优先级遵循一个约定，即数字越小表示优先级越高。有意义的流优先级的范围由 [*greatestPriority, *leastPriority] 给出。如果用户尝试创建一个优先级值超出此 API 指定的有意义范围的流，则优先级将自动向下或向上钳制为*leastPriority或*greatestPriority]。有关创建优先级流的详细信息，请参阅 cudaStreamCreateWithPriority。可以为以下项传入 NULL*leastPriority或*greatestPriority如果不需要该值。

如果当前上下文的设备不支持流优先级（请参阅 cudaDeviceGetAttribute），则此函数将在两者中返回“0”*leastPriority和*greatestPriority如果当前上下文的设备不支持流优先级（请参阅 cudaDeviceGetAttribute）。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaStreamCreateWithPriority, cudaStreamGetPriority, cuCtxGetStreamPriorityRange

__host__ ​cudaError_t cudaDeviceGetTexture1DLinearMaxWidth ( size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int  device )
返回给定元素大小的 1D 线性纹理中可分配的最大元素数。
参数
maxWidthInElements
- 返回为给定值可分配的最大纹理元素数fmtDesc.
fmtDesc
- 纹理格式描述。
device
返回值

cudaSuccess, cudaErrorUnsupportedLimit, cudaErrorInvalidValue

描述

在maxWidthInElements给定格式描述符的 1D 线性纹理中可分配的最大元素数fmtDesc.

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cuDeviceGetTexture1DLinearMaxWidth

__host__ ​cudaError_t cudaDeviceRegisterAsyncNotification ( int  device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback )
注册一个回调函数以接收异步通知。
参数
device
- 要在其上注册回调的设备
callbackFunc
- 要注册为回调的函数
userData
- 指向用户数据的通用指针。这会传递到回调函数中。
callback
- 表示已注册回调实例的句柄
返回值

cudaSuccesscudaErrorNotSupportedcudaErrorInvalidDevicecudaErrorInvalidValuecudaErrorNotPermittedcudaErrorUnknown

描述

注册callbackFunc以接收异步通知。

的userData参数在异步通知时传递给回调函数。同样，callback也传递给回调函数，以区分多个已注册的回调。

正在注册的回调函数应设计为快速返回（约 10 毫秒）。任何长时间运行的任务都应排队在应用程序线程上执行。

回调函数不得调用 cudaDeviceRegisterAsyncNotification 或 cudaDeviceUnregisterAsyncNotification。这样做将导致 cudaErrorNotPermitted。异步通知回调以未定义的顺序执行，并且可能会被序列化。

在*callback表示已注册回调实例的句柄。

属性的设备

注意

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceUnregisterAsyncNotification

__host__ ​cudaError_t cudaDeviceReset ( void )
销毁当前进程中当前设备上的所有分配并重置所有状态。
返回值

cudaSuccess

描述

显式销毁并清理与当前进程中当前设备关联的所有资源。调用者有责任确保在后续 API 调用中不访问或传递这些资源，否则将导致未定义的行为。这些资源包括 CUDA 类型 cudaStream_t、cudaEvent_t、cudaArray_t、cudaMipmappedArray_t、cudaPitchedPtr、cudaTextureObject_t、cudaSurfaceObject_t、textureReference、surfaceReference、cudaExternalMemory_t、cudaExternalSemaphore_t 和 cudaGraphicsResource_t。这些资源还包括通过 cudaMalloc、cudaMallocHost、cudaMallocManaged 和 cudaMallocPitch 进行的内存分配。对此设备的任何后续 API 调用都将重新初始化设备。

请注意，此函数将立即重置设备。调用者有责任确保在调用此函数时，进程中的任何其他主机线程都未访问该设备。

属性的设备

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceSynchronize

__host__ ​cudaError_t cudaDeviceSetCacheConfig ( cudaFuncCache cacheConfig )
为当前设备设置首选缓存配置。
参数
cacheConfig
- 请求的缓存配置
返回值

cudaSuccess

描述

在 L1 缓存和共享内存使用相同硬件资源的设备上，这会通过以下方式设置cacheConfig当前设备的首选缓存配置。这只是一个偏好设置。运行时将在可能的情况下使用请求的配置，但如果执行函数需要，它可以自由选择不同的配置。通过 cudaFuncSetCacheConfig ( C API) 或 cudaFuncSetCacheConfig ( C++ API) 设置的任何函数偏好设置都将优先于此设备范围的设置。将设备范围的缓存配置设置为 cudaFuncCachePreferNone 将导致后续内核启动优先选择不更改缓存配置，除非启动内核需要更改。

在 L1 缓存和共享内存大小固定的设备上，此设置不起作用。

使用与最近的偏好设置不同的偏好设置启动内核可能会插入设备端同步点。

支持的缓存配置为

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceGetCacheConfig, cudaFuncSetCacheConfig ( C API), cudaFuncSetCacheConfig ( C++ API), cuCtxSetCacheConfig

__host__ ​cudaError_t cudaDeviceSetLimit ( cudaLimit limit, size_t value )
设置资源限制。
参数
limit
- 要设置的限制
value
- 限制大小
返回值

cudaSuccess, cudaErrorUnsupportedLimit, cudaErrorInvalidValue, cudaErrorMemoryAllocation

描述

将limit设置为value是应用程序请求更新设备维护的当前限制。驱动程序可以自由修改请求的值以满足硬件要求（这可能是钳制为最小值或最大值，向上舍入到最接近的元素大小等）。应用程序可以使用 cudaDeviceGetLimit() 来准确了解限制已设置为多少。

设置每个 cudaLimit 都有其自身的特定限制，因此此处将讨论每个限制。

  • cudaLimitDevRuntimePendingLaunchCount 控制可以从当前设备进行的未完成设备运行时启动的最大数量。从启动点到已知网格已完成，网格都是未完成的。违反此限制的设备运行时启动将失败，并在启动后调用 cudaGetLastError() 时返回 cudaErrorLaunchPendingCountExceeded。如果使用设备运行时的模块需要比默认值（2048 次启动）更多的挂起启动，则可以增加此限制。请记住，能够维持额外的挂起启动将需要运行时预先保留更多的设备内存，这些内存将不再用于分配。如果这些预留失败，cudaDeviceSetLimit 将返回 cudaErrorMemoryAllocation，并且可以将限制重置为较低的值。此限制仅适用于计算能力为 3.5 及更高的设备。尝试在计算能力小于 3.5 的设备上设置此限制将导致返回错误 cudaErrorUnsupportedLimit。

  • cudaLimitMaxL2FetchGranularity 控制 L2 缓存提取粒度。值的范围可以从 0B 到 128B。这纯粹是一个性能提示，可以忽略或钳制，具体取决于平台。

  • cudaLimitPersistingL2CacheSize 控制可用于持久化 L2 缓存的大小（以字节为单位）。这纯粹是一个性能提示，可以忽略或钳制，具体取决于平台。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceGetLimit, cuCtxSetLimit

__host__ ​cudaError_t cudaDeviceSetMemPool ( int  device, cudaMemPool_t memPool )
设置设备的当前内存池。
返回值

cudaSuccess, cudaErrorInvalidValuecudaErrorInvalidDevicecudaErrorNotSupported

描述

内存池必须是指定设备的本地内存池。除非在 cudaMallocAsync 调用中指定了内存池，否则 cudaMallocAsync 将从所提供流的设备的当前内存池中分配内存。默认情况下，设备的当前内存池是其默认内存池。

属性的设备

使用 cudaMallocFromPoolAsync 来指定从与流运行设备不同的设备进行的异步分配。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cuDeviceSetMemPool, cudaDeviceGetMemPool, cudaDeviceGetDefaultMemPool, cudaMemPoolCreate, cudaMemPoolDestroy, cudaMallocFromPoolAsync

__host__ ​ __device__ ​cudaError_t cudaDeviceSynchronize ( void )
等待计算设备完成。
返回值

cudaSuccess

描述

阻塞，直到设备完成所有先前的请求任务。cudaDeviceSynchronize() 如果先前的任务之一失败，则返回错误。如果为此设备设置了 cudaDeviceScheduleBlockingSync 标志，则主机线程将阻塞，直到设备完成其工作。

属性的设备

  • 在设备代码中使用 cudaDeviceSynchronize 在 CUDA 11.6 中已弃用，并在 compute_90+ 编译中删除。对于计算能力 < 9.0，需要通过指定 -D CUDA_FORCE_CDP1_IF_SUPPORTED 进行编译时选择加入，以便现在继续在设备代码中使用 cudaDeviceSynchronize()。请注意，这与主机端 cudaDeviceSynchronize 不同，主机端 cudaDeviceSynchronize 仍然受支持。

  • 注意

  • 请注意，此函数也可能返回来自先前异步启动的错误代码。

  • 请注意，如果此调用尝试初始化内部 CUDA RT 状态，则此函数也可能返回 cudaErrorInitializationError、cudaErrorInsufficientDriver 或 cudaErrorNoDevice。

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceReset, cuCtxSynchronize

__host__ ​cudaError_t cudaDeviceUnregisterAsyncNotification ( int  device, cudaAsyncCallbackHandle_t callback )
注销异步通知回调。
参数
device
- 要从中删除的设备callback.
callback
- 要取消注册以接收异步通知的回调实例。
返回值

cudaSuccesscudaErrorNotSupportedcudaErrorInvalidDevicecudaErrorInvalidValuecudaErrorNotPermittedcudaErrorUnknown

描述

注销callback以便相应的回调函数将停止接收异步通知。

属性的设备

注意

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaDeviceRegisterAsyncNotification

__host__ ​ __device__ ​cudaError_t cudaGetDevice ( int* device )
返回当前正在使用的设备。
参数
device
- 返回活动主机线程在其上执行设备代码的设备。
返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorDeviceUnavailable,

描述

在*device调用主机线程的当前设备。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDeviceCount, cudaSetDevice, cudaGetDeviceProperties, cudaChooseDevice, cuCtxGetCurrent

__host__ ​ __device__ ​cudaError_t cudaGetDeviceCount ( int* count )
返回具有计算能力的设备数量。
参数
count
- 返回计算能力大于或等于 2.0 的设备数量
返回值

cudaSuccess

描述

在*count可用于执行的计算能力大于或等于 2.0 的设备数量。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDevice, cudaSetDevice, cudaGetDeviceProperties, cudaChooseDevice, cudaInitDevice, cuDeviceGetCount

__host__ ​cudaError_t cudaGetDeviceFlags ( unsigned int* flags )
获取当前设备的标志。
参数
flags
- 用于存储设备标志的指针
返回值

cudaSuccess, cudaErrorInvalidDevice

描述

在flags当前设备的标志。如果调用线程存在当前设备，则返回该设备的标志。如果不存在当前设备，则返回第一个设备的标志，这可能是默认标志。与 cudaSetDeviceFlags 的行为进行比较。

通常，返回的标志应与调用线程在此调用后使用设备时看到的行为相匹配，而不会被此线程或其他线程更改标志或当前设备。请注意，如果设备未初始化，则另一个线程可能会在设备初始化之前更改当前设备的标志。此外，当使用独占模式时，如果此线程未请求特定设备，则它可能使用除第一个设备之外的设备，这与此函数所做的假设相反。

如果上下文是通过驱动程序 API 创建的并且是调用线程的当前上下文，则始终返回该上下文的标志。

此函数返回的标志可能专门包括 cudaDeviceMapHost，即使 cudaSetDeviceFlags 不接受它，因为它在运行时 API 标志中是隐式的。原因是当前上下文可能是通过驱动程序 API 创建的，在这种情况下，标志不是隐式的，并且可能未设置。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDevice, cudaGetDeviceProperties, cudaSetDevice, cudaSetDeviceFlags, cudaInitDevice, cuCtxGetFlags, cuDevicePrimaryCtxGetState

__host__ ​cudaError_t cudaGetDeviceProperties ( cudaDeviceProp* prop, int  device )
返回有关计算设备的信息。
参数
prop
- 指定设备的属性
device
- 要获取属性的设备编号
返回值

cudaSuccess, cudaErrorInvalidDevice

描述

在*prop设备的属性dev。cudaDeviceProp 结构定义为

‎    struct cudaDeviceProp {
              char name[256];
              cudaUUID_t uuid;
              size_t totalGlobalMem;
              size_t sharedMemPerBlock;
              int regsPerBlock;
              int warpSize;
              size_t memPitch;
              int maxThreadsPerBlock;
              int maxThreadsDim[3];
              int maxGridSize[3];
              int clockRate;
              size_t totalConstMem;
              int major;
              int minor;
              size_t textureAlignment;
              size_t texturePitchAlignment;
              int deviceOverlap;
              int multiProcessorCount;
              int kernelExecTimeoutEnabled;
              int integrated;
              int canMapHostMemory;
              int computeMode;
              int maxTexture1D;
              int maxTexture1DMipmap;
              int maxTexture1DLinear;
              int maxTexture2D[2];
              int maxTexture2DMipmap[2];
              int maxTexture2DLinear[3];
              int maxTexture2DGather[2];
              int maxTexture3D[3];
              int maxTexture3DAlt[3];
              int maxTextureCubemap;
              int maxTexture1DLayered[2];
              int maxTexture2DLayered[3];
              int maxTextureCubemapLayered[2];
              int maxSurface1D;
              int maxSurface2D[2];
              int maxSurface3D[3];
              int maxSurface1DLayered[2];
              int maxSurface2DLayered[3];
              int maxSurfaceCubemap;
              int maxSurfaceCubemapLayered[2];
              size_t surfaceAlignment;
              int concurrentKernels;
              int ECCEnabled;
              int pciBusID;
              int pciDeviceID;
              int pciDomainID;
              int tccDriver;
              int asyncEngineCount;
              int unifiedAddressing;
              int memoryClockRate;
              int memoryBusWidth;
              int l2CacheSize;
              int persistingL2CacheMaxSize;
              int maxThreadsPerMultiProcessor;
              int streamPrioritiesSupported;
              int globalL1CacheSupported;
              int localL1CacheSupported;
              size_t sharedMemPerMultiprocessor;
              int regsPerMultiprocessor;
              int managedMemory;
              int isMultiGpuBoard;
              int multiGpuBoardGroupID;
              int singleToDoublePrecisionPerfRatio;
              int pageableMemoryAccess;
              int concurrentManagedAccess;
              int computePreemptionSupported;
              int canUseHostPointerForRegisteredMem;
              int cooperativeLaunch;
              int cooperativeMultiDeviceLaunch;
              int pageableMemoryAccessUsesHostPageTables;
              int directManagedMemAccessFromHost;
              int accessPolicyMaxWindowSize;
          }
其中

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDeviceCount, cudaGetDevice, cudaSetDevice, cudaChooseDevice, cudaDeviceGetAttribute, cudaInitDevice, cuDeviceGetAttribute, cuDeviceGetName

__host__ ​cudaError_t cudaInitDevice ( int  device, unsigned int  deviceFlags, unsigned int  flags )
初始化设备以用于 GPU 执行。
参数
device
- 运行时将在其上初始化的设备。
deviceFlags
- 设备操作的参数。
flags
- 用于控制设备初始化的标志。
返回值

cudaSuccess, cudaErrorInvalidDevice,

描述

此函数将初始化 CUDA 运行时结构和主上下文，device调用时，但上下文不会变为当前上下文，device.

当 cudaInitDeviceFlagsAreValid 在flags中设置时，deviceFlags 将应用于请求的设备。deviceFlags 的值与 cudaSetDeviceFlags 中的 flags 参数的值匹配。可以通过 cudaGetDeviceFlags 验证效果。

如果设备处于 cudaComputeModeExclusiveProcess 并且被另一个进程占用，或者如果设备处于 cudaComputeModeProhibited，则此函数将返回错误。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDeviceCount, cudaGetDevice, cudaGetDeviceProperties, cudaChooseDevice, cudaSetDevicecuCtxSetCurrent

__host__ ​cudaError_t cudaIpcCloseMemHandle ( void* devPtr )
尝试关闭使用 cudaIpcOpenMemHandle 映射的内存。
参数
devPtr
- cudaIpcOpenMemHandle 返回的设备指针
返回值

cudaSuccess, cudaErrorMapBufferObjectFailed, cudaErrorNotSupported, cudaErrorInvalidValue

描述

将 cudaIpcOpenMemHandle 返回的内存的引用计数减 1。当引用计数达到 0 时，此 API 将取消映射内存。导出进程中的原始分配以及其他进程中的导入映射将不受影响。

如果这是使用它们的最后一个映射，则用于启用对等访问的任何资源都将被释放。

IPC 功能仅限于支持 Linux 和 Windows 操作系统上统一寻址的设备。Windows 上的 IPC 功能出于兼容性目的而受支持，但不建议使用，因为它会带来性能成本。用户可以通过调用 cudaDeviceGetAttribute 和 cudaDevAttrIpcEventSupport 来测试其设备的 IPC 功能

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaMalloc, cudaFree, cudaIpcGetEventHandle, cudaIpcOpenEventHandle, cudaIpcGetMemHandle, cudaIpcOpenMemHandle, cudaIpcCloseMemHandle, cuIpcCloseMemHandle

__host__ ​cudaError_t cudaIpcGetEventHandle ( cudaIpcEventHandle_t* handle, cudaEvent_t event )
获取先前分配的事件的进程间句柄。
参数
handle
- 指向用户分配的 cudaIpcEventHandle 的指针，用于返回不透明的事件句柄
event
- 使用 cudaEventInterprocess 和 cudaEventDisableTiming 标志分配的事件。
返回值

cudaSuccess, cudaErrorInvalidResourceHandle, cudaErrorMemoryAllocation, cudaErrorMapBufferObjectFailed, cudaErrorNotSupported, cudaErrorInvalidValue

描述

接受先前分配的事件作为输入。此事件必须使用 cudaEventInterprocess 和 cudaEventDisableTiming 标志集创建。此不透明句柄可以复制到其他进程中，并使用 cudaIpcOpenEventHandle 打开，以实现不同进程中 GPU 工作之间的高效硬件同步。

在导入进程中打开事件后，cudaEventRecord、cudaEventSynchronize、cudaStreamWaitEvent 和 cudaEventQuery 可以在任一进程中使用。在导出的事件已通过 cudaEventDestroy 释放后，对导入的事件执行操作将导致未定义的行为。

IPC 功能仅限于支持 Linux 和 Windows 操作系统上统一寻址的设备。Windows 上的 IPC 功能出于兼容性目的而受支持，但不建议使用，因为它会带来性能成本。用户可以通过调用 cudaDeviceGetAttribute 和 cudaDevAttrIpcEventSupport 来测试其设备的 IPC 功能

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaEventCreate, cudaEventDestroy, cudaEventSynchronize, cudaEventQuery, cudaStreamWaitEvent, cudaIpcOpenEventHandle, cudaIpcGetMemHandle, cudaIpcOpenMemHandle, cudaIpcCloseMemHandle, cuIpcGetEventHandle

__host__ ​cudaError_t cudaIpcGetMemHandle ( cudaIpcMemHandle_t* handle, void* devPtr )
获取现有设备内存分配的进程间内存句柄。
参数
handle
- 指向用户分配的 cudaIpcMemHandle 的指针，用于在其中返回句柄。
devPtr
- 之前已分配设备内存的基指针
返回值

cudaSuccess, cudaErrorMemoryAllocation, cudaErrorMapBufferObjectFailed, cudaErrorNotSupported, cudaErrorInvalidValue

描述

获取使用 cudaMalloc 创建的现有设备内存分配的基址指针，并导出它以供另一个进程使用。这是一个轻量级操作，可以多次在分配上调用而不会产生不利影响。

如果使用 cudaFree 释放了内存区域，并且随后调用 cudaMalloc 返回了具有相同设备地址的内存，则 cudaIpcGetMemHandle 将为新内存返回一个唯一的句柄。

IPC 功能仅限于支持 Linux 和 Windows 操作系统上统一寻址的设备。Windows 上的 IPC 功能出于兼容性目的而受支持，但不建议使用，因为它会带来性能成本。用户可以通过调用 cudaDeviceGetAttribute 和 cudaDevAttrIpcEventSupport 来测试其设备的 IPC 功能

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaMalloc, cudaFree, cudaIpcGetEventHandle, cudaIpcOpenEventHandle, cudaIpcOpenMemHandle, cudaIpcCloseMemHandle, cuIpcGetMemHandle

__host__ ​cudaError_t cudaIpcOpenEventHandle ( cudaEvent_t* event, cudaIpcEventHandle_t handle )
打开进程间事件句柄以在当前进程中使用。
参数
event
- 返回导入的事件
handle
- 要打开的进程间句柄
返回值

cudaSuccess, cudaErrorMapBufferObjectFailed, cudaErrorNotSupported, cudaErrorInvalidValue, cudaErrorDeviceUninitialized

描述

打开从另一个进程使用 cudaIpcGetEventHandle 导出的进程间事件句柄。此函数返回一个 cudaEvent_t，其行为类似于使用 cudaEventDisableTiming 标志本地创建的事件。此事件必须使用 cudaEventDestroy 释放。

在导出事件已使用 cudaEventDestroy 释放后，对导入的事件执行操作将导致未定义的行为。

IPC 功能仅限于支持 Linux 和 Windows 操作系统上统一寻址的设备。Windows 上的 IPC 功能出于兼容性目的而受支持，但不建议使用，因为它会带来性能成本。用户可以通过调用 cudaDeviceGetAttribute 和 cudaDevAttrIpcEventSupport 来测试其设备的 IPC 功能

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaEventCreate, cudaEventDestroy, cudaEventSynchronize, cudaEventQuery, cudaStreamWaitEvent, cudaIpcGetEventHandle, cudaIpcGetMemHandle, cudaIpcOpenMemHandle, cudaIpcCloseMemHandle, cuIpcOpenEventHandle

__host__ ​cudaError_t cudaIpcOpenMemHandle ( void** devPtr, cudaIpcMemHandle_t handle, unsigned int  flags )
打开从另一个进程导出的进程间内存句柄，并返回可在本地进程中使用的设备指针。
参数
devPtr
- 返回的设备指针
handle
- 要打开的 cudaIpcMemHandle
flags
- 此操作的标志。必须指定为 cudaIpcMemLazyEnablePeerAccess
返回值

cudaSuccess, cudaErrorMapBufferObjectFailed, cudaErrorInvalidResourceHandle, cudaErrorDeviceUninitialized, cudaErrorTooManyPeers, cudaErrorNotSupported, cudaErrorInvalidValue

描述

将使用 cudaIpcGetMemHandle 从另一个进程导出的内存映射到当前设备地址空间中。对于不同设备上的上下文，cudaIpcOpenMemHandle 可以尝试在设备之间启用对等访问，就像用户调用了 cudaDeviceEnablePeerAccess 一样。此行为由 cudaIpcMemLazyEnablePeerAccess 标志控制。cudaDeviceCanAccessPeer 可以确定映射是否可能。

cudaIpcOpenMemHandle 可以打开指向进程调用 API 中可能不可见的设备的句柄。

可以打开 cudaIpcMemHandle 的上下文受到以下方式的限制。来自给定进程中每个设备的 cudaIpcMemHandle 只能由每个其他进程的每个设备的一个上下文打开。

如果内存句柄已由当前上下文打开，则句柄上的引用计数将递增 1，并返回现有的设备指针。

从 cudaIpcOpenMemHandle 返回的内存必须使用 cudaIpcCloseMemHandle 释放。

在导入上下文中调用 cudaIpcCloseMemHandle 之前，在导出的内存区域上调用 cudaFree 将导致未定义的行为。

IPC 功能仅限于支持 Linux 和 Windows 操作系统上统一寻址的设备。Windows 上的 IPC 功能出于兼容性目的而受支持，但不建议使用，因为它会带来性能成本。用户可以通过调用 cudaDeviceGetAttribute 和 cudaDevAttrIpcEventSupport 来测试其设备的 IPC 功能

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaMalloc, cudaFree, cudaIpcGetEventHandle, cudaIpcOpenEventHandle, cudaIpcGetMemHandle, cudaIpcCloseMemHandle, cudaDeviceEnablePeerAccess, cudaDeviceCanAccessPeer, cuIpcOpenMemHandle

__host__ ​cudaError_t cudaSetDevice ( int  device )
设置用于 GPU 执行的设备。
参数
device
- 活动主机线程应在其上执行设备代码的设备。
返回值

cudaSuccess, cudaErrorInvalidDevice, cudaErrorDeviceUnavailable,

描述

将device设置为调用主机线程的当前设备。 有效的设备 ID 为 0 到 (cudaGetDeviceCount() - 1)。

随后从此主机线程使用 cudaMalloc()、cudaMallocPitch() 或 cudaMallocArray() 分配的任何设备内存都将物理驻留在device上。 从此主机线程使用 cudaMallocHost() 或 cudaHostAlloc() 或 cudaHostRegister() 分配的任何主机内存都将使其生命周期与device关联。 从此主机线程创建的任何流或事件都将与device关联。 使用 <<<>>> 运算符或 cudaLaunchKernel() 从此主机线程启动的任何内核都将在device.

上执行。 可以从任何主机线程、对任何设备以及在任何时间调用此函数。 此函数不会与先前或新的设备进行任何同步，并且仅在初始化运行时的上下文状态时才会花费大量时间。 此调用会将指定设备的主上下文绑定到调用线程，并且所有后续的内存分配、流和事件创建以及内核启动都将与主上下文关联。 此函数还将立即初始化主上下文上的运行时状态，并且上下文将立即在device上变为当前上下文。 如果设备处于 cudaComputeModeExclusiveProcess 并且被另一个进程占用，或者设备处于 cudaComputeModeProhibited 状态，则此函数将返回错误。

在使用此函数之前，不需要调用 cudaInitDevice。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDeviceCount, cudaGetDevice, cudaGetDeviceProperties, cudaChooseDevice, cudaInitDevice, cuCtxSetCurrent

__host__ ​cudaError_t cudaSetDeviceFlags ( unsigned int  flags )
设置用于设备执行的标志。
参数
flags
- 设备操作的参数
返回值

cudaSuccess, cudaErrorInvalidValue

描述

记录flags作为当前设备的标志。 如果已设置当前设备且该设备已初始化，则会覆盖先前的标志。 如果当前设备尚未初始化，则会使用提供的标志对其进行初始化。 如果没有设备成为调用线程的当前设备，则会选择默认设备并使用提供的标志对其进行初始化。

参数的三个 LSB 可用于控制 CPU 线程在等待设备结果时如何与 OS 调度程序交互。flags参数的三个 LSB 可用于控制 CPU 线程在等待设备结果时如何与 OS 调度程序交互。

  • cudaDeviceScheduleAuto: 如果flags参数为零，则默认值使用基于进程中活动 CUDA 上下文数C和系统中逻辑处理器数P的启发式方法。 如果C > P，则 CUDA 在等待设备时将让步于其他 OS 线程，否则 CUDA 在等待结果时将不会让步，而是在处理器上主动自旋。 此外，在 Tegra 设备上，cudaDeviceScheduleAuto 使用基于平台功耗配置文件的启发式方法，并且可能会为低功耗设备选择 cudaDeviceScheduleBlockingSync。

  • cudaDeviceScheduleSpin: 指示 CUDA 在等待设备结果时主动自旋。 这可以减少等待设备时的延迟，但如果 CPU 线程与 CUDA 线程并行执行工作，则可能会降低 CPU 线程的性能。

  • cudaDeviceScheduleYield: 指示 CUDA 在等待设备结果时让出其线程。 这可能会增加等待设备时的延迟，但可以提高与设备并行执行工作的 CPU 线程的性能。

  • cudaDeviceScheduleBlockingSync: 指示 CUDA 在等待设备完成工作时，在同步原语上阻止 CPU 线程。

  • cudaDeviceBlockingSync: 指示 CUDA 在等待设备完成工作时，在同步原语上阻止 CPU 线程。

    Deprecated: 此标志已在 CUDA 4.0 中弃用，并替换为 cudaDeviceScheduleBlockingSync。

  • cudaDeviceMapHost: 此标志启用分配可供设备访问的固定主机内存。 对于运行时，它是隐式的，但如果使用驱动程序 API 创建上下文，则可能不存在。 如果未设置此标志，cudaHostGetDevicePointer() 将始终返回失败代码。

  • cudaDeviceLmemResizeToMax: 指示 CUDA 在调整内核的本地内存大小后不要减少本地内存。 这可以防止在启动许多具有高本地内存使用率的内核时因本地内存分配而导致的抖动，但可能会增加内存使用量。

    Deprecated: 此标志已弃用，并且此标志启用的行为现在是默认行为，无法禁用。

  • cudaDeviceSyncMemops: 确保在此上下文中启动的同步内存操作将始终同步。 有关同步内存操作可能表现出异步行为的情况的更多信息，请参阅标题为“API 同步行为”的部分。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDeviceFlags, cudaGetDeviceCount, cudaGetDevice, cudaGetDeviceProperties, cudaSetDevice, cudaSetValidDevices, cudaInitDevice, cudaChooseDevice, cuDevicePrimaryCtxSetFlags

__host__ ​cudaError_t cudaSetValidDevices ( int* device_arr, int  len )
设置可用于 CUDA 的设备列表。
参数
device_arr
- 要尝试的设备列表
len
- 指定列表中的设备数量
返回值

cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice

描述

使用device_arr按优先级顺序设置用于 CUDA 执行的设备列表。 参数len指定列表中的元素数量。 CUDA 将按顺序尝试列表中的设备，直到找到可用的设备。 如果未调用此函数，或者使用len为 0 调用此函数，则 CUDA 将恢复其默认行为，即从包含系统中所有可用 CUDA 设备的默认列表中按顺序尝试设备。 如果列表中指定的设备 ID 不存在，此函数将返回 cudaErrorInvalidDevice。 如果len不为 0 且device_arr为 NULL，或者如果len超过系统中的设备数量，则返回 cudaErrorInvalidValue。

属性的设备

请注意，根据 cudaStreamAddCallback 的规定，不得从回调中调用任何 CUDA 函数。 在这种情况下，可能会返回 cudaErrorNotPermitted 作为诊断，但不保证返回。

cudaGetDeviceCount, cudaSetDevice, cudaGetDeviceProperties, cudaSetDeviceFlags, cudaChooseDevice